Main MRPT website > C++ reference for MRPT 1.4.0
eigen_plugins.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
10// -------------------------------------------------------------------------
11// Note: This file will be included within the body of Eigen::MatrixBase
12// -------------------------------------------------------------------------
13public:
14 /** @name MRPT plugin: Types
15 * @{ */
16 // size is constant
17 enum { static_size = RowsAtCompileTime*ColsAtCompileTime };
18 /** @} */
19
20
21 /** @name MRPT plugin: Basic iterators. These iterators are intended for 1D matrices only, i.e. column or row vectors.
22 * @{ */
23 typedef Scalar* iterator;
24 typedef const Scalar* const_iterator;
25
26 EIGEN_STRONG_INLINE iterator begin() { return derived().data(); }
27 EIGEN_STRONG_INLINE iterator end() { return (&(derived().data()[size()-1]))+1; }
28 EIGEN_STRONG_INLINE const_iterator begin() const { return derived().data(); }
29 EIGEN_STRONG_INLINE const_iterator end() const { return (&(derived().data()[size()-1]))+1; }
30
31 /** @} */
32
33
34 /** @name MRPT plugin: Set/get/load/save and other miscelaneous methods
35 * @{ */
36
37 /*! Fill all the elements with a given value */
38 EIGEN_STRONG_INLINE void fill(const Scalar v) { derived().setConstant(v); }
39
40 /*! Fill all the elements with a given value */
41 EIGEN_STRONG_INLINE void assign(const Scalar v) { derived().setConstant(v); }
42 /*! Resize to N and set all the elements to a given value */
43 EIGEN_STRONG_INLINE void assign(size_t N, const Scalar v) { derived().resize(N); derived().setConstant(v); }
44
45 /** Get number of rows */
46 EIGEN_STRONG_INLINE size_t getRowCount() const { return rows(); }
47 /** Get number of columns */
48 EIGEN_STRONG_INLINE size_t getColCount() const { return cols(); }
49
50 /** Make the matrix an identity matrix (the diagonal values can be 1.0 or any other value) */
51 EIGEN_STRONG_INLINE void unit(const size_t nRows, const Scalar diag_vals) {
52 if (diag_vals==1)
53 derived().setIdentity(nRows,nRows);
54 else {
55 derived().setZero(nRows,nRows);
56 derived().diagonal().setConstant(diag_vals);
57 }
58 }
59
60 /** Make the matrix an identity matrix */
61 EIGEN_STRONG_INLINE void unit() { derived().setIdentity(); }
62 /** Make the matrix an identity matrix */
63 EIGEN_STRONG_INLINE void eye() { derived().setIdentity(); }
64
65 /** Set all elements to zero */
66 EIGEN_STRONG_INLINE void zeros() { derived().setZero(); }
67 /** Resize and set all elements to zero */
68 EIGEN_STRONG_INLINE void zeros(const size_t row,const size_t col) { derived().setZero(row,col); }
69
70 /** Resize matrix and set all elements to one */
71 EIGEN_STRONG_INLINE void ones(const size_t row, const size_t col) { derived().setOnes(row,col); }
72 /** Set all elements to one */
73 EIGEN_STRONG_INLINE void ones() { derived().setOnes(); }
74
75 /** Fast but unsafe method to obtain a pointer to a given row of the matrix (Use only in time critical applications)
76 * VERY IMPORTANT WARNING: You must be aware of the memory layout, either Column or Row-major ordering.
77 */
78 EIGEN_STRONG_INLINE Scalar * get_unsafe_row(size_t row) { return &derived().coeffRef(row,0); }
79 EIGEN_STRONG_INLINE const Scalar* get_unsafe_row(size_t row) const { return &derived().coeff(row,0); }
80
81 /** Read-only access to one element (Use with caution, bounds are not checked!) */
82 EIGEN_STRONG_INLINE Scalar get_unsafe(const size_t row, const size_t col) const {
83#ifdef _DEBUG
84 return derived()(row,col);
85#else
86 return derived().coeff(row,col);
87#endif
88 }
89 /** Reference access to one element (Use with caution, bounds are not checked!) */
90 EIGEN_STRONG_INLINE Scalar& get_unsafe(const size_t row, const size_t col) { //-V659
91#ifdef _DEBUG
92 return derived()(row,col);
93#endif
94 return derived().coeffRef(row,col);
95 }
96 /** Sets an element (Use with caution, bounds are not checked!) */
97 EIGEN_STRONG_INLINE void set_unsafe(const size_t row, const size_t col, const Scalar val) {
98#ifdef _DEBUG
99 derived()(row,col) = val;
100#endif
101 derived().coeffRef(row,col) = val;
102 }
103
104 /** Insert an element at the end of the container (for 1D vectors/arrays) */
105 EIGEN_STRONG_INLINE void push_back(Scalar val)
106 {
107 const Index N = size();
108 derived().conservativeResize(N+1);
109 coeffRef(N) = val;
110 }
111
112 EIGEN_STRONG_INLINE bool isSquare() const { return cols()==rows(); }
113 EIGEN_STRONG_INLINE bool isSingular(const Scalar absThreshold = 0) const { return std::abs(derived().determinant())<absThreshold; }
114
115 /** Read a matrix from a string in Matlab-like format, for example "[1 0 2; 0 4 -1]"
116 * The string must start with '[' and end with ']'. Rows are separated by semicolons ';' and
117 * columns in each row by one or more whitespaces ' ', commas ',' or tabs '\t'.
118 *
119 * This format is also used for CConfigFile::read_matrix.
120 *
121 * This template method can be instantiated for matrices of the types: int, long, unsinged int, unsigned long, float, double, long double
122 *
123 * \return true on success. false if the string is malformed, and then the matrix will be resized to 0x0.
124 * \sa inMatlabFormat, CConfigFile::read_matrix
125 */
126 bool fromMatlabStringFormat(const std::string &s, std::ostream *dump_errors_here = NULL);
127 // Method implemented in eigen_plugins_impl.h
128
129 /** Dump matrix in matlab format.
130 * This template method can be instantiated for matrices of the types: int, long, unsinged int, unsigned long, float, double, long double
131 * \sa fromMatlabStringFormat
132 */
133 std::string inMatlabFormat(const size_t decimal_digits = 6) const;
134 // Method implemented in eigen_plugins_impl.h
135
136 /** Save matrix to a text file, compatible with MATLAB text format (see also the methods of matrix classes themselves).
137 * \param theMatrix It can be a CMatrixTemplate or a CMatrixFixedNumeric.
138 * \param file The target filename.
139 * \param fileFormat See TMatrixTextFileFormat. The format of the numbers in the text file.
140 * \param appendMRPTHeader Insert this header to the file "% File generated by MRPT. Load with MATLAB with: VAR=load(FILENAME);"
141 * \param userHeader Additional text to be written at the head of the file. Typically MALAB comments "% This file blah blah". Final end-of-line is not needed.
142 * \sa loadFromTextFile, CMatrixTemplate::inMatlabFormat, SAVE_MATRIX
143 */
145 const std::string &file,
147 bool appendMRPTHeader = false,
148 const std::string &userHeader = std::string()
149 ) const;
150 // Method implemented in eigen_plugins_impl.h
151
152 /** Load matrix from a text file, compatible with MATLAB text format.
153 * Lines starting with '%' or '#' are interpreted as comments and ignored.
154 * \sa saveToTextFile, fromMatlabStringFormat
155 */
156 void loadFromTextFile(const std::string &file);
157 // Method implemented in eigen_plugins_impl.h
158
159 //! \overload
160 void loadFromTextFile(std::istream &_input_text_stream);
161 // Method implemented in eigen_plugins_impl.h
162
163 EIGEN_STRONG_INLINE void multiplyColumnByScalar(size_t c, Scalar s) { derived().col(c)*=s; }
164 EIGEN_STRONG_INLINE void multiplyRowByScalar(size_t r, Scalar s) { derived().row(r)*=s; }
165
166 EIGEN_STRONG_INLINE void swapCols(size_t i1,size_t i2) { derived().col(i1).swap( derived().col(i2) ); }
167 EIGEN_STRONG_INLINE void swapRows(size_t i1,size_t i2) { derived().row(i1).swap( derived().row(i2) ); }
168
169 EIGEN_STRONG_INLINE size_t countNonZero() const { return ((*static_cast<const Derived*>(this))!= 0).count(); }
170
171 /** [VECTORS OR MATRICES] Finds the maximum value
172 * \exception std::exception On an empty input container
173 */
174 EIGEN_STRONG_INLINE Scalar maximum() const
175 {
176 if (size()==0) throw std::runtime_error("maximum: container is empty");
177 return derived().maxCoeff();
178 }
179
180 /** [VECTORS OR MATRICES] Finds the minimum value
181 * \sa maximum, minimum_maximum
182 * \exception std::exception On an empty input container */
183 EIGEN_STRONG_INLINE Scalar minimum() const
184 {
185 if (size()==0) throw std::runtime_error("minimum: container is empty");
186 return derived().minCoeff();
187 }
188
189 /** [VECTORS OR MATRICES] Compute the minimum and maximum of a container at once
190 * \sa maximum, minimum
191 * \exception std::exception On an empty input container */
192 EIGEN_STRONG_INLINE void minimum_maximum(
193 Scalar & out_min,
194 Scalar & out_max) const
195 {
196 out_min = minimum();
197 out_max = maximum();
198 }
199
200
201 /** [VECTORS ONLY] Finds the maximum value (and the corresponding zero-based index) from a given container.
202 * \exception std::exception On an empty input vector
203 */
204 EIGEN_STRONG_INLINE Scalar maximum(size_t *maxIndex) const
205 {
206 if (size()==0) throw std::runtime_error("maximum: container is empty");
207 Index idx;
208 const Scalar m = derived().maxCoeff(&idx);
209 if (maxIndex) *maxIndex = idx;
210 return m;
211 }
212
213 /** [VECTORS OR MATRICES] Finds the maximum value (and the corresponding zero-based index) from a given container.
214 * \exception std::exception On an empty input vector
215 */
216 void find_index_max_value(size_t &u,size_t &v,Scalar &valMax) const
217 {
218 if (cols()==0 || rows()==0) throw std::runtime_error("find_index_max_value: container is empty");
219 Index idx1,idx2;
220 valMax = derived().maxCoeff(&idx1,&idx2);
221 u = idx1; v = idx2;
222 }
223
224
225 /** [VECTORS ONLY] Finds the minimum value (and the corresponding zero-based index) from a given container.
226 * \sa maximum, minimum_maximum
227 * \exception std::exception On an empty input vector */
228 EIGEN_STRONG_INLINE Scalar minimum(size_t *minIndex) const
229 {
230 if (size()==0) throw std::runtime_error("minimum: container is empty");
231 Index idx;
232 const Scalar m =derived().minCoeff(&idx);
233 if (minIndex) *minIndex = idx;
234 return m;
235 }
236
237 /** [VECTORS ONLY] Compute the minimum and maximum of a container at once
238 * \sa maximum, minimum
239 * \exception std::exception On an empty input vector */
240 EIGEN_STRONG_INLINE void minimum_maximum(
241 Scalar & out_min,
242 Scalar & out_max,
243 size_t *minIndex,
244 size_t *maxIndex) const
245 {
246 out_min = minimum(minIndex);
247 out_max = maximum(maxIndex);
248 }
249
250 /** Compute the norm-infinite of a vector ($f[ ||\mathbf{v}||_\infnty $f]), ie the maximum absolute value of the elements. */
251 EIGEN_STRONG_INLINE Scalar norm_inf() const { return lpNorm<Eigen::Infinity>(); }
252
253 /** Compute the square norm of a vector/array/matrix (the Euclidean distance to the origin, taking all the elements as a single vector). \sa norm */
254 EIGEN_STRONG_INLINE Scalar squareNorm() const { return squaredNorm(); }
255
256 /*! Sum all the elements, returning a value of the same type than the container */
257 EIGEN_STRONG_INLINE Scalar sumAll() const { return derived().sum(); }
258
259 /** Computes the laplacian of this square graph weight matrix.
260 * The laplacian matrix is L = D - W, with D a diagonal matrix with the degree of each node, W the
261 */
262 template<typename OtherDerived>
263 EIGEN_STRONG_INLINE void laplacian(Eigen::MatrixBase <OtherDerived>& ret) const
264 {
265 if (rows()!=cols()) throw std::runtime_error("laplacian: Defined for square matrixes only");
266 const Index N = rows();
267 ret = -(*this);
268 for (Index i=0;i<N;i++)
269 {
270 Scalar deg = 0;
271 for (Index j=0;j<N;j++) deg+= derived().coeff(j,i);
272 ret.coeffRef(i,i)+=deg;
273 }
274 }
275
276
277 /** Changes the size of matrix, maintaining its previous content as possible and padding with zeros where applicable.
278 * **WARNING**: MRPT's add-on method \a setSize() pads with zeros, while Eigen's \a resize() does NOT (new elements are undefined).
279 */
280 EIGEN_STRONG_INLINE void setSize(size_t row, size_t col)
281 {
282#ifdef _DEBUG
283 if ((Derived::RowsAtCompileTime!=Eigen::Dynamic && Derived::RowsAtCompileTime!=int(row)) || (Derived::ColsAtCompileTime!=Eigen::Dynamic && Derived::ColsAtCompileTime!=int(col))) {
284 std::stringstream ss; ss << "setSize: Trying to change a fixed sized matrix from " << rows() << "x" << cols() << " to " << row << "x" << col;
285 throw std::runtime_error(ss.str());
286 }
287#endif
288 const Index oldCols = cols();
289 const Index oldRows = rows();
290 const int nNewCols = int(col) - int(cols());
291 const int nNewRows = int(row) - int(rows());
292 ::mrpt::math::detail::TAuxResizer<Eigen::MatrixBase<Derived>,SizeAtCompileTime>::internal_resize(*this,row,col);
293 if (nNewCols>0) derived().block(0,oldCols,row,nNewCols).setZero();
294 if (nNewRows>0) derived().block(oldRows,0,nNewRows,col).setZero();
295 }
296
297 /** Efficiently computes only the biggest eigenvector of the matrix using the Power Method, and returns it in the passed vector "x". */
298 template <class OUTVECT>
300 OUTVECT &x,
301 Scalar resolution = Scalar(0.01),
302 size_t maxIterations = 6,
303 int *out_Iterations = NULL,
304 float *out_estimatedResolution = NULL ) const
305 {
306 // Apply the iterative Power Method:
307 size_t iter=0;
308 const Index n = rows();
309 x.resize(n);
310 x.setConstant(1); // Initially, set to all ones, for example...
311 Scalar dif;
312 do // Iterative loop:
313 {
314 Eigen::Matrix<Scalar,Derived::RowsAtCompileTime,1> xx = (*this) * x;
315 xx *= Scalar(1.0/xx.norm());
316 dif = (x-xx).array().abs().sum(); // Compute diference between iterations:
317 x = xx; // Set as current estimation:
318 iter++; // Iteration counter:
319 } while (iter<maxIterations && dif>resolution);
320 if (out_Iterations) *out_Iterations=static_cast<int>(iter);
321 if (out_estimatedResolution) *out_estimatedResolution=dif;
322 }
323
324 /** Combined matrix power and assignment operator */
325 MatrixBase<Derived>& operator ^= (const unsigned int pow)
326 {
327 if (pow==0)
328 derived().setIdentity();
329 else
330 for (unsigned int i=1;i<pow;i++)
331 derived() *= derived();
332 return *this;
333 }
334
335 /** Scalar power of all elements to a given power, this is diferent of ^ operator. */
336 EIGEN_STRONG_INLINE void scalarPow(const Scalar s) { (*this)=array().pow(s); }
337
338 /** Checks for matrix type */
339 EIGEN_STRONG_INLINE bool isDiagonal() const
340 {
341 for (Index c=0;c<cols();c++)
342 for (Index r=0;r<rows();r++)
343 if (r!=c && coeff(r,c)!=0)
344 return false;
345 return true;
346 }
347
348 /** Finds the maximum value in the diagonal of the matrix. */
349 EIGEN_STRONG_INLINE Scalar maximumDiagonal() const { return diagonal().maxCoeff(); }
350
351 /** Computes the mean of the entire matrix
352 * \sa meanAndStdAll */
353 EIGEN_STRONG_INLINE double mean() const
354 {
355 if ( size()==0) throw std::runtime_error("mean: Empty container.");
356 return derived().sum()/static_cast<double>(size());
357 }
358
359 /** Computes a row with the mean values of each column in the matrix and the associated vector with the standard deviation of each column.
360 * \sa mean,meanAndStdAll \exception std::exception If the matrix/vector is empty.
361 * \param unbiased_variance Standard deviation is sum(vals-mean)/K, with K=N-1 or N for unbiased_variance=true or false, respectively.
362 */
363 template <class VEC>
365 VEC &outMeanVector,
366 VEC &outStdVector,
367 const bool unbiased_variance = true ) const
368 {
369 const size_t N = rows();
370 if (N==0) throw std::runtime_error("meanAndStd: Empty container.");
371 const double N_inv = 1.0/N;
372 const double N_ = unbiased_variance ? (N>1 ? 1.0/(N-1) : 1.0) : 1.0/N;
373 outMeanVector.resize(cols());
374 outStdVector.resize(cols());
375 for (Index i=0;i<cols();i++)
376 {
377 outMeanVector[i]= this->col(i).array().sum() * N_inv;
378 outStdVector[i] = std::sqrt( (this->col(i).array()-outMeanVector[i]).square().sum() * N_ );
379 }
380 }
381
382 /** Computes the mean and standard deviation of all the elements in the matrix as a whole.
383 * \sa mean,meanAndStd \exception std::exception If the matrix/vector is empty.
384 * \param unbiased_variance Standard deviation is sum(vals-mean)/K, with K=N-1 or N for unbiased_variance=true or false, respectively.
385 */
387 double &outMean,
388 double &outStd,
389 const bool unbiased_variance = true ) const
390 {
391 const size_t N = size();
392 if (N==0) throw std::runtime_error("meanAndStdAll: Empty container.");
393 const double N_ = unbiased_variance ? (N>1 ? 1.0/(N-1) : 1.0) : 1.0/N;
394 outMean = derived().array().sum()/static_cast<double>(size());
395 outStd = std::sqrt( (this->array() - outMean).square().sum()*N_);
396 }
397
398 /** Insert matrix "m" into this matrix at indices (r,c), that is, (*this)(r,c)=m(0,0) and so on */
399 template <typename MAT>
400 EIGEN_STRONG_INLINE void insertMatrix(size_t r,size_t c, const MAT &m) { derived().block(r,c,m.rows(),m.cols())=m; }
401
402 template <typename MAT>
403 EIGEN_STRONG_INLINE void insertMatrixTranspose(size_t r,size_t c, const MAT &m) { derived().block(r,c,m.cols(),m.rows())=m.adjoint(); }
404
405 template <typename MAT> EIGEN_STRONG_INLINE void insertRow(size_t nRow, const MAT & aRow) { this->row(nRow) = aRow; }
406 template <typename MAT> EIGEN_STRONG_INLINE void insertCol(size_t nCol, const MAT & aCol) { this->col(nCol) = aCol; }
407
408 template <typename R> void insertRow(size_t nRow, const std::vector<R> & aRow)
409 {
410 if (static_cast<Index>(aRow.size())!=cols()) throw std::runtime_error("insertRow: Row size doesn't fit the size of this matrix.");
411 for (Index j=0;j<cols();j++)
412 coeffRef(nRow,j) = aRow[j];
413 }
414 template <typename R> void insertCol(size_t nCol, const std::vector<R> & aCol)
415 {
416 if (static_cast<Index>(aCol.size())!=rows()) throw std::runtime_error("insertRow: Row size doesn't fit the size of this matrix.");
417 for (Index j=0;j<rows();j++)
418 coeffRef(j,nCol) = aCol[j];
419 }
420
421 /** Remove columns of the matrix.*/
422 EIGEN_STRONG_INLINE void removeColumns(const std::vector<size_t> &idxsToRemove)
423 {
424 std::vector<size_t> idxs = idxsToRemove;
425 std::sort( idxs.begin(), idxs.end() );
426 std::vector<size_t>::iterator itEnd = std::unique( idxs.begin(), idxs.end() );
427 idxs.resize( itEnd - idxs.begin() );
428
429 unsafeRemoveColumns( idxs );
430 }
431
432 /** Remove columns of the matrix. The unsafe version assumes that, the indices are sorted in ascending order. */
433 EIGEN_STRONG_INLINE void unsafeRemoveColumns(const std::vector<size_t> &idxs)
434 {
435 size_t k = 1;
436 for (std::vector<size_t>::const_reverse_iterator it = idxs.rbegin(); it != idxs.rend(); ++it, ++k)
437 {
438 const size_t nC = cols() - *it - k;
439 if( nC > 0 )
440 derived().block(0,*it,rows(),nC) = derived().block(0,*it+1,rows(),nC).eval();
441 }
442 derived().conservativeResize(NoChange,cols()-idxs.size());
443 }
444
445 /** Remove rows of the matrix. */
446 EIGEN_STRONG_INLINE void removeRows(const std::vector<size_t> &idxsToRemove)
447 {
448 std::vector<size_t> idxs = idxsToRemove;
449 std::sort( idxs.begin(), idxs.end() );
450 std::vector<size_t>::iterator itEnd = std::unique( idxs.begin(), idxs.end() );
451 idxs.resize( itEnd - idxs.begin() );
452
453 unsafeRemoveRows( idxs );
454 }
455
456 /** Remove rows of the matrix. The unsafe version assumes that, the indices are sorted in ascending order. */
457 EIGEN_STRONG_INLINE void unsafeRemoveRows(const std::vector<size_t> &idxs)
458 {
459 size_t k = 1;
460 for (std::vector<size_t>::reverse_iterator it = idxs.rbegin(); it != idxs.rend(); ++it, ++k)
461 {
462 const size_t nR = rows() - *it - k;
463 if( nR > 0 )
464 derived().block(*it,0,nR,cols()) = derived().block(*it+1,0,nR,cols()).eval();
465 }
466 derived().conservativeResize(rows()-idxs.size(),NoChange);
467 }
468
469 /** Transpose */
470 EIGEN_STRONG_INLINE const AdjointReturnType t() const { return derived().adjoint(); }
471
472 EIGEN_STRONG_INLINE PlainObject inv() const { PlainObject outMat = derived().inverse().eval(); return outMat; }
473 template <class MATRIX> EIGEN_STRONG_INLINE void inv(MATRIX &outMat) const { outMat = derived().inverse().eval(); }
474 template <class MATRIX> EIGEN_STRONG_INLINE void inv_fast(MATRIX &outMat) const { outMat = derived().inverse().eval(); }
475 EIGEN_STRONG_INLINE Scalar det() const { return derived().determinant(); }
476
477 /** @} */ // end miscelaneous
478
479
480 /** @name MRPT plugin: Multiply and extra addition functions
481 @{ */
482
483 EIGEN_STRONG_INLINE bool empty() const { return this->getColCount()==0 || this->getRowCount()==0; }
484
485 /*! Add c (scalar) times A to this matrix: this += A * c */
486 template<typename OTHERMATRIX> EIGEN_STRONG_INLINE void add_Ac(const OTHERMATRIX &m,const Scalar c) { (*this)+=c*m; }
487 /*! Substract c (scalar) times A to this matrix: this -= A * c */
488 template<typename OTHERMATRIX> EIGEN_STRONG_INLINE void substract_Ac(const OTHERMATRIX &m,const Scalar c) { (*this) -= c*m; }
489
490 /*! Substract A transposed to this matrix: this -= A.adjoint() */
491 template<typename OTHERMATRIX> EIGEN_STRONG_INLINE void substract_At(const OTHERMATRIX &m) { (*this) -= m.adjoint(); }
492
493 /*! Substract n (integer) times A to this matrix: this -= A * n */
494 template<typename OTHERMATRIX> EIGEN_STRONG_INLINE void substract_An(const OTHERMATRIX& m, const size_t n) { this->noalias() -= n * m; }
495
496 /*! this += A + A<sup>T</sup> */
497 template<typename OTHERMATRIX> EIGEN_STRONG_INLINE void add_AAt(const OTHERMATRIX &A) { this->noalias() += A; this->noalias() += A.adjoint(); }
498
499 /*! this -= A + A<sup>T</sup> */ \
500 template<typename OTHERMATRIX> EIGEN_STRONG_INLINE void substract_AAt(const OTHERMATRIX &A) { this->noalias() -= A; this->noalias() -= A.adjoint(); }
501
502
503 template <class MATRIX1,class MATRIX2> EIGEN_STRONG_INLINE void multiply( const MATRIX1& A, const MATRIX2 &B ) /*!< this = A * B */ { (*this)= A*B; }
504
505 template <class MATRIX1,class MATRIX2>
506 EIGEN_STRONG_INLINE void multiply_AB( const MATRIX1& A, const MATRIX2 &B ) /*!< this = A * B */ {
507 (*this)= A*B;
508 }
509
510 template <typename MATRIX1,typename MATRIX2>
511 EIGEN_STRONG_INLINE void multiply_AtB(const MATRIX1 &A,const MATRIX2 &B) /*!< this=A^t * B */ {
512 *this = A.adjoint() * B;
513 }
514
515 /*! Computes the vector vOut = this * vIn, where "vIn" is a column vector of the appropriate length. */
516 template<typename OTHERVECTOR1,typename OTHERVECTOR2>
517 EIGEN_STRONG_INLINE void multiply_Ab(const OTHERVECTOR1 &vIn,OTHERVECTOR2 &vOut,bool accumToOutput = false) const {
518 if (accumToOutput) vOut.noalias() += (*this) * vIn;
519 else vOut = (*this) * vIn;
520 }
521
522 /*! Computes the vector vOut = this<sup>T</sup> * vIn, where "vIn" is a column vector of the appropriate length. */ \
523 template<typename OTHERVECTOR1,typename OTHERVECTOR2>
524 EIGEN_STRONG_INLINE void multiply_Atb(const OTHERVECTOR1 &vIn,OTHERVECTOR2 &vOut,bool accumToOutput = false) const {
525 if (accumToOutput) vOut.noalias() += this->adjoint() * vIn;
526 else vOut = this->adjoint() * vIn;
527 }
528
529 template <typename MAT_C, typename MAT_R>
530 EIGEN_STRONG_INLINE void multiply_HCHt(const MAT_C &C,MAT_R &R,bool accumResultInOutput=false) const /*!< R = this * C * this<sup>T</sup> */ {
531 if (accumResultInOutput)
532 R.noalias() += (*this) * C * this->adjoint();
533 else R.noalias() = (*this) * C * this->adjoint();
534 }
535
536 template <typename MAT_C, typename MAT_R>
537 EIGEN_STRONG_INLINE void multiply_HtCH(const MAT_C &C,MAT_R &R,bool accumResultInOutput=false) const /*!< R = this<sup>T</sup> * C * this */ {
538 if (accumResultInOutput)
539 R.noalias() += this->adjoint() * C * (*this);
540 else R.noalias() = this->adjoint() * C * (*this);
541 }
542
543 /*! R = H * C * H<sup>T</sup> (with a vector H and a symmetric matrix C) In fact when H is a vector, multiply_HCHt_scalar and multiply_HtCH_scalar are exactly equivalent */
544 template <typename MAT_C>
545 EIGEN_STRONG_INLINE Scalar multiply_HCHt_scalar(const MAT_C &C) const {
546 return ( (*this) * C * this->adjoint() ).eval()(0,0);
547 }
548
549 /*! R = H<sup>T</sup> * C * H (with a vector H and a symmetric matrix C) In fact when H is a vector, multiply_HCHt_scalar and multiply_HtCH_scalar are exactly equivalent */
550 template <typename MAT_C>
551 EIGEN_STRONG_INLINE Scalar multiply_HtCH_scalar(const MAT_C &C) const {
552 return ( this->adjoint() * C * (*this) ).eval()(0,0);
553 }
554
555 /*! this = C * C<sup>T</sup> * f (with a matrix C and a scalar f). */
556 template<typename MAT_A>
557 EIGEN_STRONG_INLINE void multiply_AAt_scalar(const MAT_A &A,typename MAT_A::Scalar f) {
558 *this = (A * A.adjoint()) * f;
559 }
560
561 /*! this = C<sup>T</sup> * C * f (with a matrix C and a scalar f). */
562 template<typename MAT_A> EIGEN_STRONG_INLINE void multiply_AtA_scalar(const MAT_A &A,typename MAT_A::Scalar f) {
563 *this = (A.adjoint() * A) * f;
564 }
565
566 /*! this = A * skew(v), with \a v being a 3-vector (or 3-array) and skew(v) the skew symmetric matrix of v (see mrpt::math::skew_symmetric3) */
567 template <class MAT_A,class SKEW_3VECTOR> void multiply_A_skew3(const MAT_A &A,const SKEW_3VECTOR &v) {
568 mrpt::math::multiply_A_skew3(A,v,*this); }
569
570 /*! this = skew(v)*A, with \a v being a 3-vector (or 3-array) and skew(v) the skew symmetric matrix of v (see mrpt::math::skew_symmetric3) */
571 template <class SKEW_3VECTOR,class MAT_A> void multiply_skew3_A(const SKEW_3VECTOR &v,const MAT_A &A) {
572 mrpt::math::multiply_skew3_A(v,A,*this); }
573
574 /** outResult = this * A
575 */
576 template <class MAT_A,class MAT_OUT>
577 EIGEN_STRONG_INLINE void multiply_subMatrix(const MAT_A &A,MAT_OUT &outResult,const size_t A_cols_offset,const size_t A_rows_offset,const size_t A_col_count) const {
578 outResult = derived() * A.block(A_rows_offset,A_cols_offset,derived().cols(),A_col_count);
579 }
580
581 template <class MAT_A,class MAT_B,class MAT_C>
582 void multiply_ABC(const MAT_A &A, const MAT_B &B, const MAT_C &C) /*!< this = A*B*C */ {
583 *this = A*B*C;
584 }
585
586 template <class MAT_A,class MAT_B,class MAT_C>
587 void multiply_ABCt(const MAT_A &A, const MAT_B &B, const MAT_C &C) /*!< this = A*B*(C<sup>T</sup>) */ {
588 *this = A*B*C.adjoint();
589 }
590
591 template <class MAT_A,class MAT_B,class MAT_C>
592 void multiply_AtBC(const MAT_A &A, const MAT_B &B, const MAT_C &C) /*!< this = A(<sup>T</sup>)*B*C */ {
593 *this = A.adjoint()*B*C;
594 }
595
596 template <class MAT_A,class MAT_B>
597 EIGEN_STRONG_INLINE void multiply_ABt(const MAT_A &A,const MAT_B &B) /*!< this = A * B<sup>T</sup> */ {
598 *this = A*B.adjoint();
599 }
600
601 template <class MAT_A>
602 EIGEN_STRONG_INLINE void multiply_AAt(const MAT_A &A) /*!< this = A * A<sup>T</sup> */ {
603 *this = A*A.adjoint();
604 }
605
606 template <class MAT_A>
607 EIGEN_STRONG_INLINE void multiply_AtA(const MAT_A &A) /*!< this = A<sup>T</sup> * A */ {
608 *this = A.adjoint()*A;
609 }
610
611 template <class MAT_A,class MAT_B>
612 EIGEN_STRONG_INLINE void multiply_result_is_symmetric(const MAT_A &A,const MAT_B &B) /*!< this = A * B (result is symmetric) */ {
613 *this = A*B;
614 }
615
616
617 /** Matrix left divide: RES = A<sup>-1</sup> * this , with A being squared (using the Eigen::ColPivHouseholderQR method) */
618 template<class MAT2,class MAT3 >
619 EIGEN_STRONG_INLINE void leftDivideSquare(const MAT2 &A, MAT3 &RES) const
620 {
621 Eigen::ColPivHouseholderQR<PlainObject> QR = A.colPivHouseholderQr();
622 if (!QR.isInvertible()) throw std::runtime_error("leftDivideSquare: Matrix A is not invertible");
623 RES = QR.inverse() * (*this);
624 }
625
626 /** Matrix right divide: RES = this * B<sup>-1</sup>, with B being squared (using the Eigen::ColPivHouseholderQR method) */
627 template<class MAT2,class MAT3 >
628 EIGEN_STRONG_INLINE void rightDivideSquare(const MAT2 &B, MAT3 &RES) const
629 {
630 Eigen::ColPivHouseholderQR<PlainObject> QR = B.colPivHouseholderQr();
631 if (!QR.isInvertible()) throw std::runtime_error("rightDivideSquare: Matrix B is not invertible");
632 RES = (*this) * QR.inverse();
633 }
634
635 /** @} */ // end multiply functions
636
637
638 /** @name MRPT plugin: Eigenvalue / Eigenvectors
639 @{ */
640
641 /** [For square matrices only] Compute the eigenvectors and eigenvalues (sorted), both returned as matrices: eigenvectors are the columns in "eVecs", and eigenvalues in ascending order as the diagonal of "eVals".
642 * \note Warning: Only the real part of complex eigenvectors and eigenvalues are returned.
643 * \sa eigenVectorsSymmetric, eigenVectorsVec
644 */
645 template <class MATRIX1,class MATRIX2>
646 EIGEN_STRONG_INLINE void eigenVectors( MATRIX1 & eVecs, MATRIX2 & eVals ) const;
647 // Implemented in eigen_plugins_impl.h (can't be here since Eigen::SelfAdjointEigenSolver isn't defined yet at this point.
648
649 /** [For square matrices only] Compute the eigenvectors and eigenvalues (sorted), eigenvectors are the columns in "eVecs", and eigenvalues are returned in in ascending order in the vector "eVals".
650 * \note Warning: Only the real part of complex eigenvectors and eigenvalues are returned.
651 * \sa eigenVectorsSymmetric, eigenVectorsVec
652 */
653 template <class MATRIX1,class VECTOR1>
654 EIGEN_STRONG_INLINE void eigenVectorsVec( MATRIX1 & eVecs, VECTOR1 & eVals ) const;
655 // Implemented in eigen_plugins_impl.h
656
657 /** [For square matrices only] Compute the eigenvectors and eigenvalues (sorted), and return only the eigenvalues in the vector "eVals".
658 * \note Warning: Only the real part of complex eigenvectors and eigenvalues are returned.
659 * \sa eigenVectorsSymmetric, eigenVectorsVec
660 */
661 template <class VECTOR>
662 EIGEN_STRONG_INLINE void eigenValues( VECTOR & eVals ) const
663 {
664 PlainObject eVecs;
665 eVecs.resizeLike(*this);
666 this->eigenVectorsVec(eVecs,eVals);
667 }
668
669 /** [For symmetric matrices only] Compute the eigenvectors and eigenvalues (in no particular order), both returned as matrices: eigenvectors are the columns, and eigenvalues \sa eigenVectors
670 */
671 template <class MATRIX1,class MATRIX2>
672 EIGEN_STRONG_INLINE void eigenVectorsSymmetric( MATRIX1 & eVecs, MATRIX2 & eVals ) const;
673 // Implemented in eigen_plugins_impl.h (can't be here since Eigen::SelfAdjointEigenSolver isn't defined yet at this point.
674
675 /** [For symmetric matrices only] Compute the eigenvectors and eigenvalues (in no particular order), both returned as matrices: eigenvectors are the columns, and eigenvalues \sa eigenVectorsVec
676 */
677 template <class MATRIX1,class VECTOR1>
678 EIGEN_STRONG_INLINE void eigenVectorsSymmetricVec( MATRIX1 & eVecs, VECTOR1 & eVals ) const;
679 // Implemented in eigen_plugins_impl.h
680
681
682 /** @} */ // end eigenvalues
683
684
685
686 /** @name MRPT plugin: Linear algebra & decomposition-based methods
687 @{ */
688
689 /** Cholesky M=U<sup>T</sup> * U decomposition for simetric matrix (upper-half of the matrix will be actually ignored) */
690 template <class MATRIX> EIGEN_STRONG_INLINE bool chol(MATRIX &U) const
691 {
692 Eigen::LLT<PlainObject> Chol = derived().template selfadjointView<Eigen::Lower>().llt();
693 if (Chol.info()==Eigen::NoConvergence)
694 return false;
695 U = PlainObject(Chol.matrixU());
696 return true;
697 }
698
699 /** Gets the rank of the matrix via the Eigen::ColPivHouseholderQR method
700 * \param threshold If set to >0, it's used as threshold instead of Eigen's default one.
701 */
702 EIGEN_STRONG_INLINE size_t rank(double threshold=0) const
703 {
704 Eigen::ColPivHouseholderQR<PlainObject> QR = this->colPivHouseholderQr();
705 if (threshold>0) QR.setThreshold(threshold);
706 return QR.rank();
707 }
708
709 /** @} */ // end linear algebra
710
711
712
713 /** @name MRPT plugin: Scalar and element-wise extra operators
714 @{ */
715
716 /** Scales all elements such as the minimum & maximum values are shifted to the given values */
717 void normalize(Scalar valMin, Scalar valMax)
718 {
719 if (size()==0) return;
720 Scalar curMin,curMax;
721 minimum_maximum(curMin,curMax);
722 Scalar minMaxDelta = curMax - curMin;
723 if (minMaxDelta==0) minMaxDelta = 1;
724 const Scalar minMaxDelta_ = (valMax-valMin)/minMaxDelta;
725 this->array() = (this->array()-curMin)*minMaxDelta_+valMin;
726 }
727 //! \overload
728 inline void adjustRange(Scalar valMin, Scalar valMax) { normalize(valMin,valMax); }
729
730 /** @} */ // end Scalar
731
732
733 /** Extract one row from the matrix into a row vector */
734 template <class OtherDerived> EIGEN_STRONG_INLINE void extractRow(size_t nRow, Eigen::EigenBase<OtherDerived> &v, size_t startingCol = 0) const {
735 v = derived().block(nRow,startingCol,1,cols()-startingCol);
736 }
737 //! \overload
738 template <typename T> inline void extractRow(size_t nRow, std::vector<T> &v, size_t startingCol = 0) const {
739 const size_t N = cols()-startingCol;
740 v.resize(N);
741 for (size_t i=0;i<N;i++) v[i]=(*this)(nRow,startingCol+i);
742 }
743 /** Extract one row from the matrix into a column vector */
744 template <class VECTOR> EIGEN_STRONG_INLINE void extractRowAsCol(size_t nRow, VECTOR &v, size_t startingCol = 0) const
745 {
746 v = derived().adjoint().block(startingCol,nRow,cols()-startingCol,1);
747 }
748
749
750 /** Extract one column from the matrix into a column vector */
751 template <class VECTOR> EIGEN_STRONG_INLINE void extractCol(size_t nCol, VECTOR &v, size_t startingRow = 0) const {
752 v = derived().block(startingRow,nCol,rows()-startingRow,1);
753 }
754 //! \overload
755 template <typename T> inline void extractCol(size_t nCol, std::vector<T> &v, size_t startingRow = 0) const {
756 const size_t N = rows()-startingRow;
757 v.resize(N);
758 for (size_t i=0;i<N;i++) v[i]=(*this)(startingRow+i,nCol);
759 }
760
761 template <class MATRIX> EIGEN_STRONG_INLINE void extractMatrix(const size_t firstRow, const size_t firstCol, MATRIX &m) const
762 {
763 m = derived().block(firstRow,firstCol,m.rows(),m.cols());
764 }
765 template <class MATRIX> EIGEN_STRONG_INLINE void extractMatrix(const size_t firstRow, const size_t firstCol, const size_t nRows, const size_t nCols, MATRIX &m) const
766 {
767 m.resize(nRows,nCols);
768 m = derived().block(firstRow,firstCol,nRows,nCols);
769 }
770
771 /** Get a submatrix, given its bounds: first & last column and row (inclusive). */
772 template <class MATRIX>
773 EIGEN_STRONG_INLINE void extractSubmatrix(const size_t row_first,const size_t row_last,const size_t col_first,const size_t col_last,MATRIX &out) const
774 {
775 out.resize(row_last-row_first+1,col_last-col_first+1);
776 out = derived().block(row_first,col_first,row_last-row_first+1,col_last-col_first+1);
777 }
778
779 /** Get a submatrix from a square matrix, by collecting the elements M(idxs,idxs), where idxs is a sequence {block_indices(i):block_indices(i)+block_size-1} for all "i" up to the size of block_indices.
780 * A perfect application of this method is in extracting covariance matrices of a subset of variables from the full covariance matrix.
781 * \sa extractSubmatrix, extractSubmatrixSymmetrical
782 */
783 template <class MATRIX>
785 const size_t block_size,
786 const std::vector<size_t> &block_indices,
787 MATRIX& out) const
788 {
789 if (block_size<1) throw std::runtime_error("extractSubmatrixSymmetricalBlocks: block_size must be >=1");
790 if (cols()!=rows()) throw std::runtime_error("extractSubmatrixSymmetricalBlocks: Matrix is not square.");
791
792 const size_t N = block_indices.size();
793 const size_t nrows_out=N*block_size;
794 out.resize(nrows_out,nrows_out);
795 if (!N) return; // Done
796 for (size_t dst_row_blk=0;dst_row_blk<N; ++dst_row_blk )
797 {
798 for (size_t dst_col_blk=0;dst_col_blk<N; ++dst_col_blk )
799 {
800#if defined(_DEBUG)
801 if (block_indices[dst_col_blk]*block_size + block_size-1>=size_t(cols())) throw std::runtime_error("extractSubmatrixSymmetricalBlocks: Indices out of range!");
802#endif
803 out.block(dst_row_blk * block_size,dst_col_blk * block_size, block_size,block_size)
804 =
805 derived().block(block_indices[dst_row_blk] * block_size, block_indices[dst_col_blk] * block_size, block_size,block_size);
806 }
807 }
808 }
809
810
811 /** Get a submatrix from a square matrix, by collecting the elements M(idxs,idxs), where idxs is the sequence of indices passed as argument.
812 * A perfect application of this method is in extracting covariance matrices of a subset of variables from the full covariance matrix.
813 * \sa extractSubmatrix, extractSubmatrixSymmetricalBlocks
814 */
815 template <class MATRIX>
817 const std::vector<size_t> &indices,
818 MATRIX& out) const
819 {
820 if (cols()!=rows()) throw std::runtime_error("extractSubmatrixSymmetrical: Matrix is not square.");
821
822 const size_t N = indices.size();
823 const size_t nrows_out=N;
824 out.resize(nrows_out,nrows_out);
825 if (!N) return; // Done
826 for (size_t dst_row_blk=0;dst_row_blk<N; ++dst_row_blk )
827 for (size_t dst_col_blk=0;dst_col_blk<N; ++dst_col_blk )
828 out.coeffRef(dst_row_blk,dst_col_blk) = this->coeff(indices[dst_row_blk],indices[dst_col_blk]);
829 }
830
void find_index_max_value(size_t &u, size_t &v, Scalar &valMax) const
[VECTORS OR MATRICES] Finds the maximum value (and the corresponding zero-based index) from a given c...
EIGEN_STRONG_INLINE void eye()
Make the matrix an identity matrix
Definition: eigen_plugins.h:63
EIGEN_STRONG_INLINE Scalar multiply_HtCH_scalar(const MAT_C &C) const
EIGEN_STRONG_INLINE Scalar det() const
EIGEN_STRONG_INLINE void multiply_AAt_scalar(const MAT_A &A, typename MAT_A::Scalar f)
void multiply_ABCt(const MAT_A &A, const MAT_B &B, const MAT_C &C)
EIGEN_STRONG_INLINE Scalar maximum() const
[VECTORS OR MATRICES] Finds the maximum value
void multiply_ABC(const MAT_A &A, const MAT_B &B, const MAT_C &C)
EIGEN_STRONG_INLINE void eigenValues(VECTOR &eVals) const
[For square matrices only] Compute the eigenvectors and eigenvalues (sorted), and return only the eig...
EIGEN_STRONG_INLINE void eigenVectors(MATRIX1 &eVecs, MATRIX2 &eVals) const
[For square matrices only] Compute the eigenvectors and eigenvalues (sorted), both returned as matric...
void adjustRange(Scalar valMin, Scalar valMax)
This is an overloaded member function, provided for convenience. It differs from the above function o...
EIGEN_STRONG_INLINE void zeros()
Set all elements to zero.
Definition: eigen_plugins.h:66
EIGEN_STRONG_INLINE size_t rank(double threshold=0) const
Gets the rank of the matrix via the Eigen::ColPivHouseholderQR method.
EIGEN_STRONG_INLINE void multiply(const MATRIX1 &A, const MATRIX2 &B)
void saveToTextFile(const std::string &file, mrpt::math::TMatrixTextFileFormat fileFormat=mrpt::math::MATRIX_FORMAT_ENG, bool appendMRPTHeader=false, const std::string &userHeader=std::string()) const
Save matrix to a text file, compatible with MATLAB text format (see also the methods of matrix classe...
EIGEN_STRONG_INLINE void multiply_AAt(const MAT_A &A)
void largestEigenvector(OUTVECT &x, Scalar resolution=Scalar(0.01), size_t maxIterations=6, int *out_Iterations=NULL, float *out_estimatedResolution=NULL) const
Efficiently computes only the biggest eigenvector of the matrix using the Power Method,...
EIGEN_STRONG_INLINE void inv_fast(MATRIX &outMat) const
EIGEN_STRONG_INLINE void swapRows(size_t i1, size_t i2)
EIGEN_STRONG_INLINE bool isDiagonal() const
Checks for matrix type.
Scalar * iterator
Definition: eigen_plugins.h:23
EIGEN_STRONG_INLINE double mean() const
Computes the mean of the entire matrix.
EIGEN_STRONG_INLINE void substract_An(const OTHERMATRIX &m, const size_t n)
EIGEN_STRONG_INLINE void assign(const Scalar v)
Definition: eigen_plugins.h:41
EIGEN_STRONG_INLINE bool empty() const
EIGEN_STRONG_INLINE void set_unsafe(const size_t row, const size_t col, const Scalar val)
Sets an element (Use with caution, bounds are not checked!)
Definition: eigen_plugins.h:97
EIGEN_STRONG_INLINE void extractSubmatrix(const size_t row_first, const size_t row_last, const size_t col_first, const size_t col_last, MATRIX &out) const
Get a submatrix, given its bounds: first & last column and row (inclusive).
EIGEN_STRONG_INLINE void insertMatrixTranspose(size_t r, size_t c, const MAT &m)
EIGEN_STRONG_INLINE Scalar multiply_HCHt_scalar(const MAT_C &C) const
EIGEN_STRONG_INLINE void extractRowAsCol(size_t nRow, VECTOR &v, size_t startingCol=0) const
Extract one row from the matrix into a column vector.
EIGEN_STRONG_INLINE void fill(const Scalar v)
Definition: eigen_plugins.h:38
void meanAndStd(VEC &outMeanVector, VEC &outStdVector, const bool unbiased_variance=true) const
Computes a row with the mean values of each column in the matrix and the associated vector with the s...
EIGEN_STRONG_INLINE size_t getRowCount() const
Get number of rows.
Definition: eigen_plugins.h:46
void multiply_A_skew3(const MAT_A &A, const SKEW_3VECTOR &v)
EIGEN_STRONG_INLINE void scalarPow(const Scalar s)
Scalar power of all elements to a given power, this is diferent of ^ operator.
EIGEN_STRONG_INLINE void unsafeRemoveRows(const std::vector< size_t > &idxs)
Remove rows of the matrix.
bool fromMatlabStringFormat(const std::string &s, std::ostream *dump_errors_here=NULL)
Read a matrix from a string in Matlab-like format, for example "[1 0 2; 0 4 -1]" The string must star...
EIGEN_STRONG_INLINE Scalar sumAll() const
EIGEN_STRONG_INLINE void multiplyRowByScalar(size_t r, Scalar s)
EIGEN_STRONG_INLINE bool chol(MATRIX &U) const
Cholesky M=UT * U decomposition for simetric matrix (upper-half of the matrix will be actually ignore...
void multiply_skew3_A(const SKEW_3VECTOR &v, const MAT_A &A)
EIGEN_STRONG_INLINE void add_AAt(const OTHERMATRIX &A)
EIGEN_STRONG_INLINE bool isSquare() const
EIGEN_STRONG_INLINE void ones(const size_t row, const size_t col)
Resize matrix and set all elements to one.
Definition: eigen_plugins.h:71
EIGEN_STRONG_INLINE Scalar * get_unsafe_row(size_t row)
Fast but unsafe method to obtain a pointer to a given row of the matrix (Use only in time critical ap...
Definition: eigen_plugins.h:78
EIGEN_STRONG_INLINE Scalar minimum() const
[VECTORS OR MATRICES] Finds the minimum value
EIGEN_STRONG_INLINE void add_Ac(const OTHERMATRIX &m, const Scalar c)
EIGEN_STRONG_INLINE void unit(const size_t nRows, const Scalar diag_vals)
Make the matrix an identity matrix (the diagonal values can be 1.0 or any other value)
Definition: eigen_plugins.h:51
EIGEN_STRONG_INLINE void multiply_Atb(const OTHERVECTOR1 &vIn, OTHERVECTOR2 &vOut, bool accumToOutput=false) const
EIGEN_STRONG_INLINE void extractRow(size_t nRow, Eigen::EigenBase< OtherDerived > &v, size_t startingCol=0) const
Extract one row from the matrix into a row vector.
EIGEN_STRONG_INLINE void multiply_AtA_scalar(const MAT_A &A, typename MAT_A::Scalar f)
EIGEN_STRONG_INLINE void eigenVectorsSymmetric(MATRIX1 &eVecs, MATRIX2 &eVals) const
[For symmetric matrices only] Compute the eigenvectors and eigenvalues (in no particular order),...
EIGEN_STRONG_INLINE void insertMatrix(size_t r, size_t c, const MAT &m)
Insert matrix "m" into this matrix at indices (r,c), that is, (*this)(r,c)=m(0,0) and so on.
EIGEN_STRONG_INLINE void minimum_maximum(Scalar &out_min, Scalar &out_max) const
[VECTORS OR MATRICES] Compute the minimum and maximum of a container at once
EIGEN_STRONG_INLINE void multiply_AB(const MATRIX1 &A, const MATRIX2 &B)
EIGEN_STRONG_INLINE void multiply_HCHt(const MAT_C &C, MAT_R &R, bool accumResultInOutput=false) const
EIGEN_STRONG_INLINE void multiply_AtB(const MATRIX1 &A, const MATRIX2 &B)
EIGEN_STRONG_INLINE void setSize(size_t row, size_t col)
Changes the size of matrix, maintaining its previous content as possible and padding with zeros where...
EIGEN_STRONG_INLINE void unsafeRemoveColumns(const std::vector< size_t > &idxs)
Remove columns of the matrix.
EIGEN_STRONG_INLINE PlainObject inv() const
void meanAndStdAll(double &outMean, double &outStd, const bool unbiased_variance=true) const
Computes the mean and standard deviation of all the elements in the matrix as a whole.
const Scalar * const_iterator
Definition: eigen_plugins.h:24
EIGEN_STRONG_INLINE void insertRow(size_t nRow, const MAT &aRow)
EIGEN_STRONG_INLINE Scalar squareNorm() const
Compute the square norm of a vector/array/matrix (the Euclidean distance to the origin,...
EIGEN_STRONG_INLINE void extractMatrix(const size_t firstRow, const size_t firstCol, MATRIX &m) const
EIGEN_STRONG_INLINE void multiplyColumnByScalar(size_t c, Scalar s)
@ static_size
Definition: eigen_plugins.h:17
EIGEN_STRONG_INLINE void push_back(Scalar val)
Insert an element at the end of the container (for 1D vectors/arrays)
void normalize(Scalar valMin, Scalar valMax)
Scales all elements such as the minimum & maximum values are shifted to the given values.
EIGEN_STRONG_INLINE Scalar maximumDiagonal() const
Finds the maximum value in the diagonal of the matrix.
EIGEN_STRONG_INLINE void eigenVectorsSymmetricVec(MATRIX1 &eVecs, VECTOR1 &eVals) const
[For symmetric matrices only] Compute the eigenvectors and eigenvalues (in no particular order),...
EIGEN_STRONG_INLINE void multiply_Ab(const OTHERVECTOR1 &vIn, OTHERVECTOR2 &vOut, bool accumToOutput=false) const
EIGEN_STRONG_INLINE Scalar norm_inf() const
Compute the norm-infinite of a vector ($f[ ||\mathbf{v}||_\infnty $f]), ie the maximum absolute value...
EIGEN_STRONG_INLINE const AdjointReturnType t() const
Transpose.
EIGEN_STRONG_INLINE size_t getColCount() const
Get number of columns.
Definition: eigen_plugins.h:48
void extractSubmatrixSymmetricalBlocks(const size_t block_size, const std::vector< size_t > &block_indices, MATRIX &out) const
Get a submatrix from a square matrix, by collecting the elements M(idxs,idxs), where idxs is a sequen...
EIGEN_STRONG_INLINE void rightDivideSquare(const MAT2 &B, MAT3 &RES) const
Matrix right divide: RES = this * B-1, with B being squared (using the Eigen::ColPivHouseholderQR met...
EIGEN_STRONG_INLINE void removeRows(const std::vector< size_t > &idxsToRemove)
Remove rows of the matrix.
EIGEN_STRONG_INLINE void multiply_ABt(const MAT_A &A, const MAT_B &B)
EIGEN_STRONG_INLINE void substract_At(const OTHERMATRIX &m)
EIGEN_STRONG_INLINE iterator begin()
Definition: eigen_plugins.h:26
std::string inMatlabFormat(const size_t decimal_digits=6) const
Dump matrix in matlab format.
EIGEN_STRONG_INLINE void substract_AAt(const OTHERMATRIX &A)
EIGEN_STRONG_INLINE Scalar get_unsafe(const size_t row, const size_t col) const
Read-only access to one element (Use with caution, bounds are not checked!)
Definition: eigen_plugins.h:82
void loadFromTextFile(const std::string &file)
Load matrix from a text file, compatible with MATLAB text format.
EIGEN_STRONG_INLINE void substract_Ac(const OTHERMATRIX &m, const Scalar c)
EIGEN_STRONG_INLINE void leftDivideSquare(const MAT2 &A, MAT3 &RES) const
Matrix left divide: RES = A-1 * this , with A being squared (using the Eigen::ColPivHouseholderQR met...
EIGEN_STRONG_INLINE void removeColumns(const std::vector< size_t > &idxsToRemove)
Remove columns of the matrix.
EIGEN_STRONG_INLINE void multiply_HtCH(const MAT_C &C, MAT_R &R, bool accumResultInOutput=false) const
EIGEN_STRONG_INLINE iterator end()
Definition: eigen_plugins.h:27
EIGEN_STRONG_INLINE void eigenVectorsVec(MATRIX1 &eVecs, VECTOR1 &eVals) const
[For square matrices only] Compute the eigenvectors and eigenvalues (sorted), eigenvectors are the co...
MatrixBase< Derived > & operator^=(const unsigned int pow)
Combined matrix power and assignment operator.
void multiply_AtBC(const MAT_A &A, const MAT_B &B, const MAT_C &C)
EIGEN_STRONG_INLINE void swapCols(size_t i1, size_t i2)
EIGEN_STRONG_INLINE void multiply_result_is_symmetric(const MAT_A &A, const MAT_B &B)
EIGEN_STRONG_INLINE void insertCol(size_t nCol, const MAT &aCol)
EIGEN_STRONG_INLINE void multiply_subMatrix(const MAT_A &A, MAT_OUT &outResult, const size_t A_cols_offset, const size_t A_rows_offset, const size_t A_col_count) const
outResult = this * A
EIGEN_STRONG_INLINE void laplacian(Eigen::MatrixBase< OtherDerived > &ret) const
Computes the laplacian of this square graph weight matrix.
EIGEN_STRONG_INLINE void extractCol(size_t nCol, VECTOR &v, size_t startingRow=0) const
Extract one column from the matrix into a column vector.
EIGEN_STRONG_INLINE bool isSingular(const Scalar absThreshold=0) const
void extractSubmatrixSymmetrical(const std::vector< size_t > &indices, MATRIX &out) const
Get a submatrix from a square matrix, by collecting the elements M(idxs,idxs), where idxs is the sequ...
EIGEN_STRONG_INLINE size_t countNonZero() const
EIGEN_STRONG_INLINE void multiply_AtA(const MAT_A &A)
T abs(T x)
Definition: nanoflann.hpp:237
void multiply_skew3_A(const SKEW_3VECTOR &v, const MAT_A &A, MAT_OUT &out)
Only for vectors/arrays "v" of length3, compute out = Skew(v) * A, where Skew(v) is the skew symmetri...
Definition: ops_matrices.h:169
TMatrixTextFileFormat
Definition: math_frwds.h:65
@ MATRIX_FORMAT_ENG
engineering format 'e'
Definition: math_frwds.h:66
size_t size(const MATRIXLIKE &m, int dim)
Definition: bits.h:38
CONTAINER::Scalar sum(const CONTAINER &v)
Computes the sum of all the elements.
void multiply_A_skew3(const MAT_A &A, const SKEW_3VECTOR &v, MAT_OUT &out)
Only for vectors/arrays "v" of length3, compute out = A * Skew(v), where Skew(v) is the skew symmetri...
Definition: ops_matrices.h:150
T square(const T x)
Inline function for the square of a number.
Definition: bits.h:113
Internal resize which compiles to nothing on fixed-size matrices.
Definition: math_frwds.h:50



Page generated by Doxygen 1.9.2 for MRPT 1.4.0 SVN: at Mon Sep 20 00:21:41 UTC 2021