TooN 2.1
Public Member Functions
SVD< Rows, Cols, Precision > Class Template Reference

Performs SVD and back substitute to solve equations. More...

#include <TooN/SVD.h>

List of all members.

Public Member Functions

 SVD ()
 SVD (int rows, int cols)
template<int R2, int C2, typename P2 , typename B2 >
 SVD (const Matrix< R2, C2, P2, B2 > &m)
template<int R2, int C2, typename P2 , typename B2 >
void compute (const Matrix< R2, C2, P2, B2 > &m)
template<int Rows2, int Cols2, typename P2 , typename B2 >
Matrix< Cols, Cols2, typename
Internal::MultiplyType
< Precision, P2 >::type > 
backsub (const Matrix< Rows2, Cols2, P2, B2 > &rhs, const Precision condition=condition_no)
template<int Size, typename P2 , typename B2 >
Vector< Cols, typename
Internal::MultiplyType
< Precision, P2 >::type > 
backsub (const Vector< Size, P2, B2 > &rhs, const Precision condition=condition_no)
Matrix< Cols, Rows > get_pinv (const Precision condition=condition_no)
Precision determinant ()
int rank (const Precision condition=condition_no)
Matrix< Rows, Min_Dim,
Precision, Reference::RowMajor
get_U ()
Vector< Min_Dim, Precision > & get_diagonal ()
Matrix< Min_Dim, Cols,
Precision, Reference::RowMajor
get_VT ()
void get_inv_diag (Vector< Min_Dim > &inv_diag, const Precision condition)

Detailed Description

template<int Rows = Dynamic, int Cols = Rows, typename Precision = DefaultPrecision>
class TooN::SVD< Rows, Cols, Precision >

Performs SVD and back substitute to solve equations.

Singular value decompositions are more robust than LU decompositions in the face of singular or nearly singular matrices. They decompose a matrix (of any shape) $M$ into:

\[M = U \times D \times V^T\]

where $D$ is a diagonal matrix of positive numbers whose dimension is the minimum of the dimensions of $M$. If $M$ is tall and thin (more rows than columns) then $U$ has the same shape as $M$ and $V$ is square (vice-versa if $M$ is short and fat). The columns of $U$ and the rows of $V$ are orthogonal and of unit norm (so one of them lies in SO(N)). The inverse of $M$ (or pseudo-inverse if $M$ is not square) is then given by

\[M^{\dagger} = V \times D^{-1} \times U^T\]

If $M$ is nearly singular then the diagonal matrix $D$ has some small values (relative to its largest value) and these terms dominate $D^{-1}$. To deal with this problem, the inverse is conditioned by setting a maximum ratio between the largest and smallest values in $D$ (passed as the condition parameter to the various functions). Any values which are too small are set to zero in the inverse (rather than a large number)

It can be used as follows to solve the $M\underline{x} = \underline{c}$ problem as follows:

// construct M
Matrix<3> M;
M[0] = makeVector(1,2,3);
M[1] = makeVector(4,5,6);
M[2] = makeVector(7,8.10);
// construct c
 Vector<3> c;
c = 2,3,4;
// create the SVD decomposition of M
SVD<3> svdM(M);
// compute x = M^-1 * c
Vector<3> x = svdM.backsub(c);

SVD<> (= SVD<-1>) can be used to create an SVD whose size is determined at run-time.


Constructor & Destructor Documentation

SVD ( const Matrix< R2, C2, P2, B2 > &  m)

Construct the SVD decomposition of a matrix.

This initialises the class, and performs the decomposition immediately.


Member Function Documentation

Matrix<Cols,Cols2, typename Internal::MultiplyType<Precision,P2>::type > backsub ( const Matrix< Rows2, Cols2, P2, B2 > &  rhs,
const Precision  condition = condition_no 
)

Calculate result of multiplying the (pseudo-)inverse of M by another matrix.

For a matrix $A$, this calculates $M^{\dagger}A$ by back substitution (i.e. without explictly calculating the (pseudo-)inverse). See the detailed description for a description of condition variables.

Vector<Cols, typename Internal::MultiplyType<Precision,P2>::type > backsub ( const Vector< Size, P2, B2 > &  rhs,
const Precision  condition = condition_no 
)

Calculate result of multiplying the (pseudo-)inverse of M by a vector.

For a vector $b$, this calculates $M^{\dagger}b$ by back substitution (i.e. without explictly calculating the (pseudo-)inverse). See the detailed description for a description of condition variables.

Matrix<Cols,Rows> get_pinv ( const Precision  condition = condition_no)

Calculate (pseudo-)inverse of the matrix.

This is not usually needed: if you need the inverse just to multiply it by a matrix or a vector, use one of the backsub() functions, which will be faster. See the detailed description of the pseudo-inverse and condition variables.

int rank ( const Precision  condition = condition_no)

Calculate the rank of the matrix.

See the detailed description of the pseudo-inverse and condition variables.

void get_inv_diag ( Vector< Min_Dim > &  inv_diag,
const Precision  condition 
)

Return the pesudo-inverse diagonal.

The reciprocal of the diagonal elements is returned if the elements are well scaled with respect to the largest element, otherwise 0 is returned.

Parameters:
inv_diagVector in which to return the inverse diagonal.
conditionElements must be larger than this factor times the largest diagonal element to be considered well scaled.

Referenced by SVD< Size, Size, Precision >::backsub(), and SVD< Size, Size, Precision >::get_pinv().