#include <matrix.hh>
Public Member Functions | |
const double & | operator() (int r, int c) const |
const double & | operator[] (const std::pair< int, int > &row_col) const |
double & | operator[] (const std::pair< int, int > &row_col) |
double & | operator() (int r, int c) |
const Vector & | operator[] (int r) const |
Vector & | operator[] (int r) |
int | num_rows () const |
int | num_cols () const |
Construction and destruction | |
Matrix () | |
Matrix (int rows, int cols) | |
Matrix (Precision *p) | |
Matrix (Precision *p, int r, int c) | |
Matrix (Precision *data, int rows, int cols, int rowstride, int colstride, Internal::Slicing) | |
template<class Op > | |
Matrix (const Operator< Op > &op) | |
template<int Rows2, int Cols2, typename Precision2 , typename Base2 > | |
Matrix (const Matrix< Rows2, Cols2, Precision2, Base2 > &from) | |
Assignment | |
operator = from copy | |
Matrix & | operator= (const Matrix &from) |
template<class Op > | |
Matrix & | operator= (const Operator< Op > &op) |
template<int Rows2, int Cols2, typename Precision2 , typename Base2 > | |
Matrix & | operator= (const Matrix< Rows2, Cols2, Precision2, Base2 > &from) |
operations on the matrix | |
Matrix & | operator*= (const Precision &rhs) |
Matrix & | operator/= (const Precision &rhs) |
template<int Rows2, int Cols2, typename Precision2 , typename Base2 > | |
Matrix & | operator+= (const Matrix< Rows2, Cols2, Precision2, Base2 > &from) |
template<class Op > | |
Matrix & | operator+= (const Operator< Op > &op) |
template<class Op > | |
Matrix & | operator-= (const Operator< Op > &op) |
template<int Rows2, int Cols2, typename Precision2 , typename Base2 > | |
Matrix & | operator-= (const Matrix< Rows2, Cols2, Precision2, Base2 > &from) |
template<int Rows2, int Cols2, typename Precision2 , typename Base2 > | |
bool | operator== (const Matrix< Rows2, Cols2, Precision2, Base2 > &rhs) |
template<int Rows2, int Cols2, typename Precision2 , typename Base2 > | |
bool | operator!= (const Matrix< Rows2, Cols2, Precision2, Base2 > &rhs) |
Misc | |
Matrix & | ref () |
Transpose and sub-matrices | |
const Matrix< Cols, Rows > & | T () const |
Matrix< Cols, Rows > & | T () |
template<Rstart , Cstart , Rsize , Csize > | |
const Matrix< Rsize, Csize > & | slice () const |
template<Rstart , Cstart , Rsize , Csize > | |
Matrix< Rsize, Csize > & | slice () |
const Matrix & | slice (int rstart, int cstart, int rsize, int csize) const |
Matrix & | slice (int rstart, int cstart, int rsize, int csize) |
Support is provided for all the usual matrix operations:
See individual member function documentation for examples of usage.
Matrix<3,4> M;
Matrix<3> M;
Matrix<3,3>
. Matrices can also be constructed from pointers or static 1D or 2D arrays of doubles: double dvals1[9]={1,2,3,4,5,6};
Matrix<2,3, Reference::RowMajor> M2 (dvals1);
Half-dynamic matriced can be constructed in either dimension:
Matrix<Dynamic, 2> M(num_rows, 2);
Matrix<>
is a synonym for Matrix<Dynamic, Dynamic>
which is Matrix<-1,-1>
You can override the default for a specific matrix by specifying the layout when you construct it:
Matrix<3,3,double,ColMajor> M1; Matrix<-1,-1,double,RowMajor> M2(nrows, ncols);
Matrix | ( | ) |
Construction of static matrices. Values are not initialized.
Matrix | ( | int | rows, | |
int | cols | |||
) |
Construction of dynamic matrices. Values are not initialized.
Matrix | ( | Precision * | p | ) |
Construction of statically sized slice matrices.
Matrix | ( | Precision * | p, | |
int | r, | |||
int | c | |||
) |
Construction of dynamically sized slice matrices.
Matrix | ( | Precision * | data, | |
int | rows, | |||
int | cols, | |||
int | rowstride, | |||
int | colstride, | |||
Internal::Slicing | ||||
) |
Advanced construction of dynamically sized slice matrices.
Internal constructor used by GenericMBase::slice(...).
Matrix | ( | const Operator< Op > & | op | ) |
Construction from an operator.
Matrix& ref | ( | ) |
return me as a non const reference - useful for temporaries
const double& operator() | ( | int | r, | |
int | c | |||
) | const |
Access an element from the matrix.
The index starts at zero, i.e. the top-left element is m(0, 0).
double d[2][3] = {{1, 2, 3}, {4, 5, 6}}; Matrix<2,3> m(d); double e = m(1,2); // now e = 6.0;
const double& operator[] | ( | const std::pair< int, int > & | row_col | ) | const |
Access an element from the matrix.
row_col | row_col.first holds the row, row_col.second holds the column. |
double& operator[] | ( | const std::pair< int, int > & | row_col | ) |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
double& operator() | ( | int | r, | |
int | c | |||
) |
Access an element from the matrix.
This can be used as either an r-value or an l-value. The index starts at zero, i.e. the top-left element is m(0, 0).
double d[2][3] = {{1, 2, 3}, {4, 5, 6}}; Matrix<2,3> m(d); m(1,2) = 8; // now d = [1 2 3] // [4 5 8]
const Vector& operator[] | ( | int | r | ) | const |
Access a row from the matrix.
This can be used either as an r-value or an l-value. The index starts at zero, i.e. the first row is m[0]. To extract a column from a matrix, apply [] to the transpose of the matrix (see example). This can be used either as an r-value or an l-value. The index starts at zero, i.e. the first row (or column) is m[0].
double d[2][3] = {{1, 2, 3}, {4, 5, 6}}; Matrix<2,3> m(d); Vector<3> v = m[1]; // now v = [4 5 6]; Vector<2> v2 = m.T()[0]; // now v2 = [1 4];
Vector& operator[] | ( | int | r | ) |
Access a row from the matrix.
This can be used either as an r-value or an l-value. The index starts at zero, i.e. the first row is m[0]. To extract a column from a matrix, apply [] to the transpose of the matrix (see example). This can be used either as an r-value or an l-value. The index starts at zero, i.e. the first row (or column) is m[0].
double d[2][3] = {{1, 2, 3}, {4, 5, 6}}; Matrix<2,3> m(d); Zero(m[0]); // set the first row to zero Vector<2> v = 8,9; m.T()[1] = v; // now m = [0 8 0] // [4 9 6]
int num_rows | ( | ) | const |
How many rows does this matrix have?
Referenced by WLS< Size, Precision >::add_mJ(), WLS< Size, Precision >::add_prior(), SE3< Precision >::adjoint(), LU< Size, Precision >::backsub(), Cholesky< Size, Precision >::backsub(), Cholesky< Size, Precision >::Cholesky(), WLS< Size, Precision >::compute(), SymEigen< Size, Precision >::compute(), LU< Size, Precision >::compute(), Cholesky< Size, Precision >::compute(), LU< Size, Precision >::determinant(), TooN::determinant(), Cholesky< Size, Precision >::determinant(), TooN::determinant_gaussian_elimination(), TooN::determinant_LU(), TooN::exp(), TooN::Fill(), DownhillSimplex< N, Precision >::find_next_point(), TooN::gauss_jordan(), TooN::gaussian_elimination(), LU< Size, Precision >::get_inverse(), Cholesky< Size, Precision >::get_inverse(), SVD< Size, Size, Precision >::get_U(), SVD< Size, Size, Precision >::get_VT(), TooN::norm_1(), TooN::norm_fro(), TooN::norm_inf(), DownhillSimplex< N, Precision >::restart(), TooN::Symmetrize(), TooN::trace(), and SE3< Precision >::trinvadjoint().
int num_cols | ( | ) | const |
How many columns does this matrix have?
Referenced by SE3< Precision >::adjoint(), LU< Size, Precision >::backsub(), Cholesky< Size, Precision >::backsub(), Cholesky< Size, Precision >::Cholesky(), SymEigen< Size, Precision >::compute(), LU< Size, Precision >::compute(), Cholesky< Size, Precision >::compute(), TooN::determinant(), TooN::determinant_gaussian_elimination(), TooN::determinant_LU(), TooN::exp(), TooN::Fill(), DownhillSimplex< N, Precision >::find_next_point(), TooN::gauss_jordan(), TooN::gaussian_elimination(), SVD< Size, Size, Precision >::get_U(), SVD< Size, Size, Precision >::get_VT(), TooN::norm_1(), TooN::norm_fro(), TooN::norm_inf(), TooN::project(), DownhillSimplex< N, Precision >::restart(), TooN::Symmetrize(), TooN::trace(), and SE3< Precision >::trinvadjoint().
const Matrix<Cols, Rows>& T | ( | ) | const |
The transpose of the matrix.
This is a very fast operation--it simply reinterprets a row-major matrix as column-major or vice-versa. This can be used as an l-value.
double d[2][3] = {{1, 2, 3}, {4, 5, 6}}; Matrix<2,3> m(d); Zero(m[0]); // set the first row to zero Vector<2> v = 8,9; m.T()[1] = v; // now m = [0 8 0] // [4 9 6]
Referenced by WLS< Size, Precision >::add_mJ(), SE3< Precision >::adjoint(), SymEigen< Size, Precision >::backsub(), SymEigen< Size, Precision >::get_isqrtm(), SymEigen< Size, Precision >::get_pinv(), GR_SVD< M, N, Precision, WANT_U, WANT_V >::get_pinv(), SymEigen< Size, Precision >::get_sqrtm(), GR_SVD< M, N, Precision, WANT_U, WANT_V >::reorder(), SO3< P >::SO3(), and SE3< Precision >::trinvadjoint().
Matrix<Cols, Rows>& T | ( | ) |
The transpose of the matrix.
This is a very fast operation--it simply reinterprets a row-major matrix as column-major or vice-versa. The result can be used as an l-value.
double d[2][3] = {{1, 2, 3}, {4, 5, 6}}; Matrix<2,3> m(d); Vector<2> v = 8,9; // Set the first column to v m.T()[0] = v; // now m = [8 2 3] // [9 5 6]
M=M.T()
are broken. In general, it is not necessary to say M=M.T()
, since you can use M.T() for free whenever you need the transpose, but if you do need to, you have to use the Tranpose() function defined in helpers.h
.
const Matrix<Rsize, Csize>& slice | ( | ) | const |
Extract a sub-matrix.
The matrix extracted will be begin at element (Rstart, Cstart) and will contain the next Rsize by Csize elements.
double d[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; Matrix<3> m(d); Extract the top-left 2x2 matrix Matrix<2> b = m.slice<0,0,2,2>(); // b = [1 2] // [4 5]
Referenced by TooN::project().
Matrix<Rsize, Csize>& slice | ( | ) |
Extract a sub-matrix.
The matrix extracted will be begin at element (Rstart, Cstart) and will contain the next Rsize by Csize elements. This can be used as either an r-value or an l-value.
double d[2][3] = {{1, 2, 3}, {4, 5, 6}}; Matrix<2,3> m(d); Zero(m.slice<0,2,2,1>()); // b = [1 2 0] // [4 5 0]
const Matrix& slice | ( | int | rstart, | |
int | cstart, | |||
int | rsize, | |||
int | csize | |||
) | const |
Extract a sub-matrix with runtime location and size.
The matrix extracted will begin at element (rstart, cstart) and will contain the next rsize by csize elements.
Matrix<> m(3,3); Extract the top-left 2x2 matrix Matrix<2> b = m.slice(0,0,2,2);
Matrix& slice | ( | int | rstart, | |
int | cstart, | |||
int | rsize, | |||
int | csize | |||
) |
Extract a sub-matrix with runtime location and size, which can be used as an l-value.
The matrix extracted will be begin at element (rstart, cstart) and will contain the next rsize by csize elements.
Matrix<> m(3,3); Zero(m.slice(0,0,2,2));