38 EIGEN_STRONG_INLINE
void fill(
const Scalar v) { derived().setConstant(v); }
41 EIGEN_STRONG_INLINE
void assign(
const Scalar v) { derived().setConstant(v); }
43 EIGEN_STRONG_INLINE
void assign(
size_t N,
const Scalar v) { derived().resize(N); derived().setConstant(v); }
46 EIGEN_STRONG_INLINE
size_t getRowCount()
const {
return rows(); }
48 EIGEN_STRONG_INLINE
size_t getColCount()
const {
return cols(); }
51 EIGEN_STRONG_INLINE
void unit(
const size_t nRows,
const Scalar diag_vals) {
53 derived().setIdentity(nRows,nRows);
55 derived().setZero(nRows,nRows);
56 derived().diagonal().setConstant(diag_vals);
61 EIGEN_STRONG_INLINE
void unit() { derived().setIdentity(); }
63 EIGEN_STRONG_INLINE
void eye() { derived().setIdentity(); }
66 EIGEN_STRONG_INLINE
void zeros() { derived().setZero(); }
68 EIGEN_STRONG_INLINE
void zeros(
const size_t row,
const size_t col) { derived().setZero(row,col); }
71 EIGEN_STRONG_INLINE
void ones(
const size_t row,
const size_t col) { derived().setOnes(row,col); }
73 EIGEN_STRONG_INLINE
void ones() { derived().setOnes(); }
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); }
82 EIGEN_STRONG_INLINE Scalar
get_unsafe(
const size_t row,
const size_t col)
const {
84 return derived()(row,col);
86 return derived().coeff(row,col);
90 EIGEN_STRONG_INLINE Scalar&
get_unsafe(
const size_t row,
const size_t col) {
92 return derived()(row,col);
94 return derived().coeffRef(row,col);
97 EIGEN_STRONG_INLINE
void set_unsafe(
const size_t row,
const size_t col,
const Scalar val) {
99 derived()(row,col) = val;
101 derived().coeffRef(row,col) = val;
107 const Index N =
size();
108 derived().conservativeResize(N+1);
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; }
145 const std::string &file,
147 bool appendMRPTHeader =
false,
148 const std::string &userHeader = std::string()
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) ); }
169 EIGEN_STRONG_INLINE
size_t countNonZero()
const {
return ((*
static_cast<const Derived*
>(
this))!= 0).count(); }
176 if (
size()==0)
throw std::runtime_error(
"maximum: container is empty");
177 return derived().maxCoeff();
185 if (
size()==0)
throw std::runtime_error(
"minimum: container is empty");
186 return derived().minCoeff();
194 Scalar & out_max)
const
204 EIGEN_STRONG_INLINE Scalar
maximum(
size_t *maxIndex)
const
206 if (
size()==0)
throw std::runtime_error(
"maximum: container is empty");
208 const Scalar m = derived().maxCoeff(&idx);
209 if (maxIndex) *maxIndex = idx;
218 if (cols()==0 || rows()==0)
throw std::runtime_error(
"find_index_max_value: container is empty");
220 valMax = derived().maxCoeff(&idx1,&idx2);
228 EIGEN_STRONG_INLINE Scalar
minimum(
size_t *minIndex)
const
230 if (
size()==0)
throw std::runtime_error(
"minimum: container is empty");
232 const Scalar m =derived().minCoeff(&idx);
233 if (minIndex) *minIndex = idx;
244 size_t *maxIndex)
const
251 EIGEN_STRONG_INLINE Scalar
norm_inf()
const {
return lpNorm<Eigen::Infinity>(); }
254 EIGEN_STRONG_INLINE Scalar
squareNorm()
const {
return squaredNorm(); }
257 EIGEN_STRONG_INLINE Scalar
sumAll()
const {
return derived().sum(); }
262 template<
typename OtherDerived>
263 EIGEN_STRONG_INLINE
void laplacian(Eigen::MatrixBase <OtherDerived>& ret)
const
265 if (rows()!=cols())
throw std::runtime_error(
"laplacian: Defined for square matrixes only");
266 const Index N = rows();
268 for (Index i=0;i<N;i++)
271 for (Index j=0;j<N;j++) deg+= derived().coeff(j,i);
272 ret.coeffRef(i,i)+=deg;
280 EIGEN_STRONG_INLINE
void setSize(
size_t row,
size_t col)
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());
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());
293 if (nNewCols>0) derived().block(0,oldCols,row,nNewCols).setZero();
294 if (nNewRows>0) derived().block(oldRows,0,nNewRows,col).setZero();
298 template <
class OUTVECT>
301 Scalar resolution = Scalar(0.01),
302 size_t maxIterations = 6,
303 int *out_Iterations = NULL,
304 float *out_estimatedResolution = NULL )
const
308 const Index n = rows();
314 Eigen::Matrix<Scalar,Derived::RowsAtCompileTime,1> xx = (*this) * x;
315 xx *= Scalar(1.0/xx.norm());
316 dif = (x-xx).array().abs().sum();
319 }
while (iter<maxIterations && dif>resolution);
320 if (out_Iterations) *out_Iterations=
static_cast<int>(iter);
321 if (out_estimatedResolution) *out_estimatedResolution=dif;
328 derived().setIdentity();
330 for (
unsigned int i=1;i<pow;i++)
331 derived() *= derived();
336 EIGEN_STRONG_INLINE
void scalarPow(
const Scalar s) { (*this)=array().pow(s); }
341 for (Index c=0;c<cols();c++)
342 for (Index r=0;r<rows();r++)
343 if (r!=c && coeff(r,c)!=0)
353 EIGEN_STRONG_INLINE
double mean()
const
355 if (
size()==0)
throw std::runtime_error(
"mean: Empty container.");
356 return derived().sum()/
static_cast<double>(
size());
367 const bool unbiased_variance =
true )
const
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++)
377 outMeanVector[i]= this->col(i).array().sum() * N_inv;
378 outStdVector[i] = std::sqrt( (this->col(i).array()-outMeanVector[i]).
square().
sum() * N_ );
389 const bool unbiased_variance =
true )
const
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_);
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; }
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(); }
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; }
408 template <
typename R>
void insertRow(
size_t nRow,
const std::vector<R> & aRow)
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];
414 template <
typename R>
void insertCol(
size_t nCol,
const std::vector<R> & aCol)
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];
422 EIGEN_STRONG_INLINE
void removeColumns(
const std::vector<size_t> &idxsToRemove)
424 std::vector<size_t> idxs = idxsToRemove;
425 std::sort( idxs.begin(), idxs.end() );
427 idxs.resize( itEnd - idxs.begin() );
436 for (std::vector<size_t>::const_reverse_iterator it = idxs.rbegin(); it != idxs.rend(); ++it, ++k)
438 const size_t nC = cols() - *it - k;
440 derived().block(0,*it,rows(),nC) = derived().block(0,*it+1,rows(),nC).eval();
442 derived().conservativeResize(NoChange,cols()-idxs.size());
446 EIGEN_STRONG_INLINE
void removeRows(
const std::vector<size_t> &idxsToRemove)
448 std::vector<size_t> idxs = idxsToRemove;
449 std::sort( idxs.begin(), idxs.end() );
451 idxs.resize( itEnd - idxs.begin() );
460 for (std::vector<size_t>::reverse_iterator it = idxs.rbegin(); it != idxs.rend(); ++it, ++k)
462 const size_t nR = rows() - *it - k;
464 derived().block(*it,0,nR,cols()) = derived().block(*it+1,0,nR,cols()).eval();
466 derived().conservativeResize(rows()-idxs.size(),NoChange);
470 EIGEN_STRONG_INLINE
const AdjointReturnType
t()
const {
return derived().adjoint(); }
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(); }
486 template<
typename OTHERMATRIX> EIGEN_STRONG_INLINE
void add_Ac(
const OTHERMATRIX &m,
const Scalar c) { (*this)+=c*m; }
488 template<
typename OTHERMATRIX> EIGEN_STRONG_INLINE
void substract_Ac(
const OTHERMATRIX &m,
const Scalar c) { (*this) -= c*m; }
491 template<
typename OTHERMATRIX> EIGEN_STRONG_INLINE
void substract_At(
const OTHERMATRIX &m) { (*this) -= m.adjoint(); }
494 template<
typename OTHERMATRIX> EIGEN_STRONG_INLINE
void substract_An(
const OTHERMATRIX& m,
const size_t n) { this->noalias() -= n * m; }
497 template<
typename OTHERMATRIX> EIGEN_STRONG_INLINE
void add_AAt(
const OTHERMATRIX &A) { this->noalias() += A; this->noalias() += A.adjoint(); }
500 template<typename OTHERMATRIX> EIGEN_STRONG_INLINE
void substract_AAt(
const OTHERMATRIX &A) { this->noalias() -= A; this->noalias() -= A.adjoint(); }
503 template <
class MATRIX1,
class MATRIX2> EIGEN_STRONG_INLINE
void multiply(
const MATRIX1& A,
const MATRIX2 &B ) { (*this)= A*B; }
505 template <
class MATRIX1,
class MATRIX2>
506 EIGEN_STRONG_INLINE
void multiply_AB(
const MATRIX1& A,
const MATRIX2 &B ) {
510 template <
typename MATRIX1,
typename MATRIX2>
511 EIGEN_STRONG_INLINE
void multiply_AtB(
const MATRIX1 &A,
const MATRIX2 &B) {
512 *
this = A.adjoint() * B;
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;
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;
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 {
531 if (accumResultInOutput)
532 R.noalias() += (*this) * C * this->adjoint();
533 else R.noalias() = (*this) * C * this->adjoint();
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 {
538 if (accumResultInOutput)
539 R.noalias() += this->adjoint() * C * (*this);
540 else R.noalias() = this->adjoint() * C * (*this);
544 template <
typename MAT_C>
546 return ( (*
this) * C * this->adjoint() ).eval()(0,0);
550 template <
typename MAT_C>
552 return ( this->adjoint() * C * (*
this) ).eval()(0,0);
556 template<
typename MAT_A>
558 *
this = (A * A.adjoint()) * 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;
567 template <
class MAT_A,
class SKEW_3VECTOR>
void multiply_A_skew3(
const MAT_A &A,
const SKEW_3VECTOR &v) {
571 template <
class SKEW_3VECTOR,
class MAT_A>
void multiply_skew3_A(
const SKEW_3VECTOR &v,
const MAT_A &A) {
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);
581 template <
class MAT_A,
class MAT_B,
class MAT_C>
586 template <
class MAT_A,
class MAT_B,
class MAT_C>
588 *
this = A*B*C.adjoint();
591 template <
class MAT_A,
class MAT_B,
class MAT_C>
593 *
this = A.adjoint()*B*C;
596 template <
class MAT_A,
class MAT_B>
598 *
this = A*B.adjoint();
601 template <
class MAT_A>
603 *
this = A*A.adjoint();
606 template <
class MAT_A>
608 *
this = A.adjoint()*A;
611 template <
class MAT_A,
class MAT_B>
618 template<
class MAT2,
class MAT3 >
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);
627 template<
class MAT2,
class MAT3 >
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();
645 template <
class MATRIX1,
class MATRIX2>
646 EIGEN_STRONG_INLINE
void eigenVectors( MATRIX1 & eVecs, MATRIX2 & eVals )
const;
653 template <
class MATRIX1,
class VECTOR1>
661 template <
class VECTOR>
665 eVecs.resizeLike(*
this);
671 template <
class MATRIX1,
class MATRIX2>
677 template <
class MATRIX1,
class VECTOR1>
690 template <
class MATRIX> EIGEN_STRONG_INLINE
bool chol(MATRIX &U)
const
692 Eigen::LLT<PlainObject> Chol = derived().template selfadjointView<Eigen::Lower>().llt();
693 if (Chol.info()==Eigen::NoConvergence)
695 U = PlainObject(Chol.matrixU());
702 EIGEN_STRONG_INLINE
size_t rank(
double threshold=0)
const
704 Eigen::ColPivHouseholderQR<PlainObject> QR = this->colPivHouseholderQr();
705 if (threshold>0) QR.setThreshold(threshold);
719 if (
size()==0)
return;
720 Scalar 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;
735 v = derived().block(nRow,startingCol,1,cols()-startingCol);
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;
741 for (
size_t i=0;i<N;i++) v[i]=(*
this)(nRow,startingCol+i);
744 template <
class VECTOR> EIGEN_STRONG_INLINE
void extractRowAsCol(
size_t nRow, VECTOR &v,
size_t startingCol = 0)
const
746 v = derived().adjoint().block(startingCol,nRow,cols()-startingCol,1);
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);
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;
758 for (
size_t i=0;i<N;i++) v[i]=(*
this)(startingRow+i,nCol);
761 template <
class MATRIX> EIGEN_STRONG_INLINE
void extractMatrix(
const size_t firstRow,
const size_t firstCol, MATRIX &m)
const
763 m = derived().block(firstRow,firstCol,m.rows(),m.cols());
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
767 m.resize(nRows,nCols);
768 m = derived().block(firstRow,firstCol,nRows,nCols);
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
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);
783 template <
class MATRIX>
785 const size_t block_size,
786 const std::vector<size_t> &block_indices,
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.");
792 const size_t N = block_indices.size();
793 const size_t nrows_out=N*block_size;
794 out.resize(nrows_out,nrows_out);
796 for (
size_t dst_row_blk=0;dst_row_blk<N; ++dst_row_blk )
798 for (
size_t dst_col_blk=0;dst_col_blk<N; ++dst_col_blk )
801 if (block_indices[dst_col_blk]*block_size + block_size-1>=
size_t(cols()))
throw std::runtime_error(
"extractSubmatrixSymmetricalBlocks: Indices out of range!");
803 out.block(dst_row_blk * block_size,dst_col_blk * block_size, block_size,block_size)
805 derived().block(block_indices[dst_row_blk] * block_size, block_indices[dst_col_blk] * block_size, block_size,block_size);
815 template <
class MATRIX>
817 const std::vector<size_t> &indices,
820 if (cols()!=rows())
throw std::runtime_error(
"extractSubmatrixSymmetrical: Matrix is not square.");
822 const size_t N = indices.size();
823 const size_t nrows_out=N;
824 out.resize(nrows_out,nrows_out);
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]);
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
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.
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.
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)
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!)
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)
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.
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.
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...
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)
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
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)
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.
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()
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!)
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()
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)
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...
@ MATRIX_FORMAT_ENG
engineering format 'e'
size_t size(const MATRIXLIKE &m, int dim)
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...
T square(const T x)
Inline function for the square of a number.
Internal resize which compiles to nothing on fixed-size matrices.