TooN::LU< Size, Precision > Class Template Reference

Performs LU decomposition and back substitutes to solve equations. More...

#include <LU.h>

Public Member Functions
template<int S1, int S2, class Base >
	LU (const Matrix< S1, S2, Precision, Base > &m)
	Construct the LU decomposition of a matrix. More...
template<int S1, int S2, class Base >
void	compute (const Matrix< S1, S2, Precision, Base > &m)
	Perform the LU decompsition of another matrix.
template<int Rows, int NRHS, class Base >
Matrix< Size, NRHS, Precision >	backsub (const Matrix< Rows, NRHS, Precision, Base > &rhs)
	Calculate result of multiplying the inverse of M by another matrix. More...
template<int Rows, class Base >
Vector< Size, Precision >	backsub (const Vector< Rows, Precision, Base > &rhs)
	Calculate result of multiplying the inverse of M by a vector. More...
Matrix< Size, Size, Precision >	get_inverse ()
	Calculate inverse of the matrix. More...
const Matrix< Size, Size, Precision > &	get_lu () const
	Returns the L and U matrices. More...
Precision	determinant () const
	Calculate the determinant of the matrix.
int	get_info () const
	Get the LAPACK info.

Detailed Description

template<int Size = -1, class Precision = double>
class TooN::LU< Size, Precision >

Performs LU decomposition and back substitutes to solve equations.

The LU decomposition is the fastest way of solving the equation \(M\underline{x} = \underline{c}\)m, but it becomes unstable when \(M\) is (nearly) singular (in which cases the SymEigen or SVD decompositions are better). It decomposes a matrix \(M\) into

\[M = L \times U\]

where \(L\) is a lower-diagonal matrix with unit diagonal and \(U\) is an upper-diagonal matrix. The library only supports the decomposition of square matrices. 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(3,2,1);
M[2] = makeVector(1,0,1);
// construct c
Vector<3> c = makeVector(2,3,4);
// create the LU decomposition of M
LU<3> luM(M);
// compute x = M^-1 * c
Vector<3> x = luM.backsub(c);

The convention LU<> (=LU<-1>) is used to create an LU decomposition whose size is determined at runtime.

Constructor & Destructor Documentation

LU()

template<int Size = -1, class Precision = double>

template<int S1, int S2, class Base >

TooN::LU< Size, Precision >::LU ( const Matrix< S1, S2, Precision, Base > &  m )

inline

Construct the LU decomposition of a matrix.

This initialises the class, and performs the decomposition immediately.

Member Function Documentation

backsub() [1/2]

template<int Size = -1, class Precision = double>

template<int Rows, int NRHS, class Base >

Matrix<Size,NRHS,Precision> TooN::LU< Size, Precision >::backsub ( const Matrix< Rows, NRHS, Precision, Base > &  rhs )

inline

Calculate result of multiplying the inverse of M by another matrix.

For a matrix \(A\), this calculates \(M^{-1}A\) by back substitution (i.e. without explictly calculating the inverse).

backsub() [2/2]

template<int Size = -1, class Precision = double>

template<int Rows, class Base >

Vector<Size,Precision> TooN::LU< Size, Precision >::backsub ( const Vector< Rows, Precision, Base > &  rhs )

inline

Calculate result of multiplying the inverse of M by a vector.

For a vector \(b\), this calculates \(M^{-1}b\) by back substitution (i.e. without explictly calculating the inverse).

get_inverse()

template<int Size = -1, class Precision = double>

Matrix<Size,Size,Precision> TooN::LU< Size, Precision >::get_inverse ( )

inline

Calculate 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.

get_lu()

template<int Size = -1, class Precision = double>

const Matrix<Size,Size,Precision>& TooN::LU< Size, Precision >::get_lu ( ) const

inline

Returns the L and U matrices.

The permutation matrix is not returned. Since L is lower-triangular (with unit diagonal) and U is upper-triangular, these are returned conflated into one matrix, where the diagonal and above parts of the matrix are U and the below-diagonal part, plus a unit diagonal, are L.

---

The documentation for this class was generated from the following file:

• TooN/LU.h