Matrix of variable size. More...

#include "Imagine/LinAlg.h"

Inheritance diagram for Imagine::Matrix< T >:

Public Types
typedef Base::const_iterator	const_iterator
	Const iterator type.

typedef Base::iterator	iterator
	Iterator type.

Public Types inherited from Imagine::MultiArray< T, 2 >
typedef const T *	const_iterator
	Const iterator type.

typedef T *	iterator
	Iterator type.

Public Types inherited from Imagine::Array< T >
typedef const T *	const_iterator
	Const iterator type.

typedef T *	iterator
	Iterator type.

Public Member Functions
	Matrix ()
	Empty constructor. More...

	Matrix (int M, int N)
	Constructor (known size). More...

	Matrix (T *t, int M, int N, bool handleDelete=false)
	Constructor (pre-allocated). More...

	Matrix (const Base &A)
	Copy constructor. More...

	Matrix (const SymMatrix< T > &A)
	Conversion from SymMatrix. More...

	~Matrix ()
	Destructor. More...

Matrix	clone () const
	Cloning. More...

Matrix &	fill (T x)
	Filling. More...

Vector< T >	getCol (int j) const
	Get column. More...

Vector< T >	getColRef (int j)
	Get column by reference. More...

Matrix	getColsRef (int j0, int n)
	Get part of columns by reference. More...

Vector< T >	getDiagonal () const
	Get diagonal. More...

Vector< T >	getRow (int i) const
	Get row. More...

Vector< T >	getSubColRef (int j, int i0, int m)
	Get sub column by reference. More...

Matrix	getSubMat (int i0, int m, int j0, int n) const
	Get sub matrix. More...

int	ncol () const
	Number of columns. More...

int	nrow () const
	Number of rows. More...

Vector< T >	operator* (const Vector< T > &v) const
	Product with vector. More...

Matrix	operator* (const Matrix &B) const
	Product. More...

Matrix	operator* (const SymMatrix< T > &B) const
	Product. More...

Matrix	operator* (T x) const
	Scalar multiplication. More...

Matrix &	operator*= (T x)
	Scalar in place multiplication. More...

Matrix	operator+ (const Matrix &B) const
	Addition. More...

Matrix &	operator+= (const Matrix &B)
	In place Addition. More...

Matrix	operator- (const Matrix &B) const
	Substraction. More...

Matrix	operator- () const
	Opposite. More...

Matrix &	operator-= (const Matrix &B)
	In place Substraction. More...

Matrix	operator/ (T x) const
	Scalar division. More...

Matrix &	operator/= (T x)
	Scalar in place division. More...

Matrix &	operator= (const Matrix &A)
	Assignment. More...

Matrix &	setCol (int j, const Vector< T > &v)
	Set column. More...

Matrix &	setDiagonal (const Vector< T > &v)
	Set diagonal. More...

Matrix &	setRow (int i, const Vector< T > &v)
	Set row. More...

Public Member Functions inherited from Imagine::MultiArray< T, 2 >
	MultiArray ()
	Empty constructor. More...

	MultiArray (const Coords< dim > &sz)
	Constructor (known size). More...

	MultiArray (int s0, int s1)
	Constructor (2D shorcut). More...

	MultiArray (int s0, int s1, int s2)
	Constructor (3D shorcut). More...

	MultiArray (T *ptr, const Coords< dim > &sz, bool handleDelete=false)
	Constructor (pre-allocated). More...

	MultiArray (T *ptr, int s0, int s1, bool handleDelete=false)
	Constructor (pre-allocated) 2D alias. More...

	MultiArray (T *ptr, int s0, int s1, int s2, bool handleDelete=false)
	Constructor (pre-allocated) 3D alias. More...

	MultiArray (const MultiArray &A)
	Copy constructor. More...

	MultiArray (const MultiArray< T2, dim > &A)
	Constructor (different type). More...

virtual	~MultiArray ()
	Destructor. More...

MultiArray	clone () const
	Cloning. More...

CoordsIterator< dim >	coordsBegin () const
	Begin coords iterator. More...

CoordsIterator< dim >	coordsEnd () const
	End coords iterator. More...

int	depth () const
	Size alias 2. More...

MultiArray &	fill (T x)
	Filling. More...

MultiArray	getSubArray (const Coords< dim > &offset, const Coords< dim > &sz) const
	Sub array. More...

int	height () const
	Size alias 1. More...

size_t	offset (const Coords< dim > &c) const
	Offset. More...

size_t	offset (int x, int y) const
	Offset (2D alias). More...

size_t	offset (int x, int y, int z) const
	Offset (3D alias). More...

const T &	operator() (const Coords< dim > &c) const
	Read access. More...

T &	operator() (const Coords< dim > &c)
	Write access. More...

const T &	operator() (int x, int y) const
	Read access 2D alias. More...

T &	operator() (int x, int y)
	Write access 2D alias. More...

const T &	operator() (int x, int y, int z) const
	Read access 3D alias. More...

T &	operator() (int x, int y, int z)
	Write access 3D alias. More...

MultiArray &	operator= (const MultiArray &A)
	Assignment. More...

MultiArray &	operator= (const MultiArray< T2, dim > &A)
	Assignment (different type). More...

void	setSize (const Coords< dim > &sz)
	Change sizes. More...

void	setSize (int s0, int s1)
	Change size 2D alias. More...

void	setSize (int s0, int s1, int s2)
	Change size 3D alias. More...

int	size (int i) const
	i^th size. More...

Coords< dim >	sizes () const
	Sizes. More...

FArray< size_t, dim >	stride () const
	Stride. More...

size_t	stride (int i) const
	i^th stride. More...

size_t	totalSize () const
	Total Size. More...

int	width () const
	Size alias 0. More...

Public Member Functions inherited from Imagine::Array< T >
	Array ()
	Empty constructor. More...

	Array (size_t size)
	Constructor (known size). More...

	Array (T *ptr, size_t size, bool handleDelete=false)
	Constructor (pre-allocated). More...

	Array (const Array &A)
	Copy constructor. More...

template<typename T2 >
	Array (const Array< T2 > &A)
	Constructor (different type). More...

	Array (const std::list< T > &L)
	Constructor (from list). More...

virtual	~Array ()
	Destructor. More...

iterator	begin ()
	Begin iterator. More...

const_iterator	begin () const
	Begin const iterator. More...

Array	clone () const
	Cloning. More...

T *	data ()
	Data pointer (read/write). More...

const T *	data () const
	Data pointer (read). More...

bool	empty () const
	Is empty. More...

iterator	end ()
	End iterator. More...

const_iterator	end () const
	End const iterator. More...

Array &	fill (const T &x)
	Filling. More...

Array	getSubArray (size_t offset, size_t size) const
	Sub array. More...

bool	operator!= (const Array &A) const
	Inequality test. More...

Array &	operator= (const Array &A)
	Assignment. More...

template<typename T2 >
Array &	operator= (const Array< T2 > &A)
	Assignment (different type). More...

bool	operator== (const Array &A) const
	Equality test. More...

const T &	operator[] (size_t i) const
	Read access. More...

T &	operator[] (size_t i)
	Write access. More...

void	setSize (size_t size)
	Change size. More...

size_t	size () const
	Size. More...

Static Public Member Functions
static Matrix	Identity (int N)
	Identity. More...

static Matrix	Zero (int M, int N)
	Zero matrix. More...

Friends
Matrix	cholesky (const Matrix &A, bool low=true)
	Cholesky decomposition. More...

T	det (const Matrix &A)
	Determinant. More...

T	dot (const Matrix &a, const Matrix &b)
	Scalar product. More...

Matrix	inverse (const Matrix &A)
	Inverse. More...

Vector< T >	linSolve (const Matrix &A, const Vector< T > &b)
	Linear system. More...

Matrix	multt (const Matrix &A, const Matrix &B)
	Product. More...

T	norm (const Matrix &A, char type='F')
	Norm. More...

Matrix	operator* (T x, const Matrix &B)
	Scalar multiplication. More...

std::ostream &	operator<< (std::ostream &out, const Matrix &A)
	ASCII write. More...

std::istream &	operator>> (std::istream &in, Matrix &A)
	ASCII read. More...

Matrix	pseudoInverse (const Matrix &A, T tolrel=0)
	Pseudo inverse. More...

bool	QR (const Matrix &A, Matrix &Q, Matrix &R, bool all=false)
	QR decomposition. More...

T	rcond (const Matrix &A)
	Reciprocal condition number. More...

void	svd (const Matrix &A, Matrix &U, Vector< T > &S, Matrix &Vt, bool all=false)
	SVD. More...

Vector< T >	tmult (const Matrix &A, const Vector< T > &v)
	Product with vector. More...

Matrix	tmult (const Matrix &A, const Matrix &B)
	Product. More...

Matrix	tmultt (const Matrix &A, const Matrix &B)
	Product. More...

Matrix	transpose (const Matrix &A)
	Transpose. More...

Detailed Description

template<typename T>
singleton Imagine::Matrix< T >

Matrix of variable size. Memory is reference counted, i.e.:

a=b results in a and b sharing the same memory
the last object using memory frees it when it dies
use clone() when this sharing is not desired

Parameters

T	value type

Examples:: LinAlg/test/test.cpp.

Constructor & Destructor Documentation

template<typename T>

Imagine::Matrix< T >::Matrix ( )

inline

Constructs an unallocated matrix of variables of type T

Matrix<T> A; // non allocated

template<typename T>

Imagine::Matrix< T >::Matrix	(	int	M,
		int	N
	)

inline

Constructs an allocated matrix of variables of type T

Parameters

M	number of rows
N	number of columns

Matrix<T> B(3,4); // allocated with specified size

template<typename T>

Imagine::Matrix< T >::Matrix	(	T *	t,
		int	M,
		int	N,
		bool	handleDelete = `false`
	)

inline

Constructs an MxN matrix from variables type T stored at an already allocated memory. t contains (0,0), (1,0), ... Does not allocate fresh memory. Does not free given memory at object destruction unless handleDelete=true. This memory must indeed stay available during object life.

Parameters

t	address of memory
M	number of rows
N	number of columns
handleDelete	delete memory at destruction? (default=false)

    T tt[]={1,2,3,4,5,6};                // pre-allocated
    Matrix<T> D(tt,3,2);        
    T *tt2=new T[6];
    for(int i=0; i<6; i++)
        tt2[i]=rand()/(T)RAND_MAX;
    Matrix<T> D2(tt2,3,2,true);          // ...

template<typename T>

Imagine::Matrix< T >::Matrix ( const Base & A )

inline

Constructs a matrix from another one (sharing memory!)

Parameters

A	matrix to copy

Matrix<T> C(B); // copy constructor

template<typename T>

Imagine::Matrix< T >::Matrix ( const SymMatrix< T > & A )

Constructs a matrix from a symmetric one

Parameters

A	matrix to copy

Matrix<T> P(F); // conversion SymMatrix -> Matrix

template<typename T>

Imagine::Matrix< T >::~Matrix ( )

inline

Reference counted desctructor: frees memory if the object is the last one to use it.

Member Function Documentation

template<typename T>

Matrix Imagine::Matrix< T >::clone ( ) const

inline

Clones: creates a new matrix, with fresh memory, copying values

Returns: cloned matrix

A=B.clone(); // cloning (fresh memory)

template<typename T>

Matrix& Imagine::Matrix< T >::fill ( T x )

inline

Fills with constant value

Parameters

x	value to be copied to each element

Returns: self reference

A.fill(1); // filling with constant value

template<typename T>

Vector<T> Imagine::Matrix< T >::getCol ( int j ) const

inline

Returns column of index j

Parameters

j	column index

Returns: column vector

v=A.getCol(2); // Get column

template<typename T>

Vector<T> Imagine::Matrix< T >::getColRef ( int j )

inline

Construct a vector without allocating new memory but pointing to a column of *this. Beware: *this (or its memory) must not be destroyed as long as the returned vector is used!

Parameters

j	column index

Returns: column

v=A.getColRef(2); // Vector pointing to column (beware of restrictions!)

template<typename T>

Matrix Imagine::Matrix< T >::getColsRef	(	int	j0,
		int	n
	)

inline

Construct a matrix without allocating new memory but pointing to part of columns of *this. Beware: *this (or its memory) must not be destroyed as long as the returned vector is used!

Parameters

j0	starting column index
n	number of columns

Returns: columns

B=A.getColsRef(1,2); // Matrix pointing to part of columns (beware of restrictions!)

template<typename T>

Vector<T> Imagine::Matrix< T >::getDiagonal ( ) const

inline

Returns diagonal vector of size=min(nrow,ncol)

Returns: diagonal vector

v=A.getDiagonal(); // Get diagonal

template<typename T>

Vector<T> Imagine::Matrix< T >::getRow ( int i ) const

inline

Returns row of index i

Parameters

i row index

Returns: row vector

v=A.getRow(1); // Get row

template<typename T>

Vector<T> Imagine::Matrix< T >::getSubColRef	(	int	j,
		int	i0,
		int	m
	)

inline

Construct a vector without allocating new memory but pointing to part of a column of *this. Beware: *this (or its memory) must not be destroyed as long as the returned vector is used!

Parameters

j	column index
i0	starting row
m	number of rows

Returns: column

v=A.getSubColRef(2,1,2); // Vector pointing to sub-column (beware of restrictions!)

template<typename T>

Matrix Imagine::Matrix< T >::getSubMat	(	int	i0,
		int	m,
		int	j0,
		int	n
	)		const

inline

Constructs a new matrix a copies a part of *this into it.

Parameters

i0	starting row
m	number of rows
j0	starting column
n	number of columns

B=A.getSubMat(1,2,1,2); // Get sub matrix

Examples:: LinAlg/test/test.cpp.

template<typename T>

static Matrix Imagine::Matrix< T >::Identity ( int N )

inlinestatic

Identity

Parameters

N	dimension (NxN matrix)

Returns: matrix

Matrix<T> I=Matrix<T>::Identity(4); // Identity

Examples:: LinAlg/test/test.cpp.

template<typename T>

int Imagine::Matrix< T >::ncol ( ) const

inline

Number of columns

Returns: Number of columns

/*int m=*/A.nrow(),/*n=*/A.ncol(); // Dimensions

template<typename T>

int Imagine::Matrix< T >::nrow ( ) const

inline

Number of rows

Returns: Number of rows

/*int m=*/A.nrow(),/*n=*/A.ncol(); // Dimensions

template<typename T>

Vector<T> Imagine::Matrix< T >::operator* ( const Vector< T > & v ) const

inline

Matrix vector product

Parameters

v	right operand

Returns: (this) v

w=A*v; // matrix * vector

template<typename T>

Matrix Imagine::Matrix< T >::operator* ( const Matrix< T > & B ) const

inline

Matrix matrix product

Parameters

B	right operand

Returns: *this * B

A34=A32*A24; // matrix * matrix

template<typename T>

Matrix Imagine::Matrix< T >::operator* ( const SymMatrix< T > & B ) const

Matrix symmatrix product

Parameters

B	right operand

Returns: *this * B

P=F*G; // symmatrix * symmatrix

template<typename T>

Matrix Imagine::Matrix< T >::operator* ( T x ) const

inline

Multiplies each element by a scalar

Parameters

x	The scalar

Returns: Result

C=A*2; // * scalar

template<typename T>

Matrix& Imagine::Matrix< T >::operator*= ( T x )

inline

Multiplies each element by a scalar

Parameters

x	The scalar

Returns: self reference

C*=2; // *= scalar

template<typename T>

Matrix Imagine::Matrix< T >::operator+ ( const Matrix< T > & B ) const

inline

Addition of two Matrix

Parameters

B	Matrix to be added to myself

Returns: sum

for(int i=0; i<3; i++)

template<typename T>

Matrix& Imagine::Matrix< T >::operator+= ( const Matrix< T > & B )

inline

In place Addition of Matrix

Parameters

B	Matrix to be added to myself

Returns: self reference

C+=B; // +=

template<typename T>

Matrix Imagine::Matrix< T >::operator- ( const Matrix< T > & B ) const

inline

Substraction of two Matrix

Parameters

B	Matrix to be substracted from myself

Returns: difference

T tt[]={1,2,3,4,5,6}; // pre-allocated

template<typename T>

Matrix Imagine::Matrix< T >::operator- ( ) const

inline

Opposite of a matrix

Returns: Opposite

C=-A; // unary -

template<typename T>

Matrix& Imagine::Matrix< T >::operator-= ( const Matrix< T > & B )

inline

In place Substraction of Matrix

Parameters

B	Matrix to be substracted from myself

Returns: self reference

C-=B; // -=

template<typename T>

Matrix Imagine::Matrix< T >::operator/ ( T x ) const

inline

Divides each element by a scalar

Parameters

x	The scalar

Returns: Result

C=A/2; // / scalar

template<typename T>

Matrix& Imagine::Matrix< T >::operator/= ( T x )

inline

Divides each element by a scalar

Parameters

x	The scalar

Returns: self reference

C/=2; // /= scalar

template<typename T>

Matrix& Imagine::Matrix< T >::operator= ( const Matrix< T > & A )

inline

Assigns from another matrix (sharing its memory)

Parameters

A	matrix to be assigned to

Returns: self reference

A=B; // assignment

template<typename T>

Matrix& Imagine::Matrix< T >::setCol	(	int	j,
		const Vector< T > &	v
	)

inline

Sets column of index j

Parameters

j	column index
v	column

Returns: self reference

A.setCol(1,v); // Set column

template<typename T>

Matrix& Imagine::Matrix< T >::setDiagonal ( const Vector< T > & v )

inline

Set diagonal from vector of size=min(nrow,ncol)

Parameters

v diagonal

Returns: self reference

A.setDiagonal(v); // Set diagonal

template<typename T>

Matrix& Imagine::Matrix< T >::setRow	(	int	i,
		const Vector< T > &	v
	)

inline

Sets row of index i

Parameters

i	row index
v	row

Returns: self reference

A.setRow(2,v); // Set row

template<typename T>

static Matrix Imagine::Matrix< T >::Zero	(	int	M,
		int	N
	)

inlinestatic

Matrix with constant 0 value

Parameters

M,N	dimensions

Returns: matrix

A=Matrix<T>::Zero(3,4); // Matrix with constant 0 value

Examples:: LinAlg/test/test.cpp.

Friends And Related Function Documentation

template<typename T>

Matrix cholesky	(	const Matrix< T > &	A,
		bool	low = `true`
	)

friend

Cholesky decomposition of symmetric positive-definite matrix.

Parameters

A	matrix
low	Choose lower (default) or upper true: A=LL^T with L lower false: A=U^TU with U upper

Returns: L or U

    Matrix<T> L=cholesky(B);                                     // Cholesky decomposition
    cout << "Lower Cholesky " << norm(B-L*transpose(L)) << endl; // Check lower
    U=cholesky(B,false);
    cout << "Upper Cholesky " << norm(B-transpose(U)*U) << endl; // Check upper...

template<typename T>

T det ( const Matrix< T > & A )

friend

Determinant. Uses LU decomposition.

Parameters

A matrix

Returns: determinant

cout << "Determinants: " << det(A)*det(inverse(A))-1 << endl;// Determinant

cout << "Determinants: " << det(B)*det(inverse(B))-1 << endl;// Check sym pos-def acceleration...

template<typename T>

T dot	(	const Matrix< T > &	a,
		const Matrix< T > &	b
	)

friend

Scalar product (L^2)

Parameters

a	left term
b	right term

Returns: scalar product

a=dot(A,C); // scalar product

template<typename T>

Matrix inverse ( const Matrix< T > & A )

friend

Inverse matrix. If non invertible, outputs a message to cerr and returns a matrix with zeroed elements.

Parameters

A	matrix to inverse

Returns: the inverse matrix

B=inverse(A); // inverse

template<typename T>

Vector<T> linSolve	(	const Matrix< T > &	A,
		const Vector< T > &	b
	)

friend

Solve linear system. Returns x such that:

M=N, square system: Ax=b
M>N, over determined system: x=argmin_y|Ay-b|
M<N, under determined system: x=argmin_{y,Ay=b}|y|

Parameters

A	matrix
b	right term

Returns: solution (zeroed vector if no solution)

    initRandom(1);                                             // Linear solve
    A.setSize(5,5);
    for (int i=0;i<5;i++)
        for (int j=0;j<5;j++)
            A(i,j)=T(doubleRandom());
    Vector<T> b(5),x;
    for (int j=0;j<5;j++)
            b[j]=T(doubleRandom());
    x=linSolve(A,b);
    cout << "Square system: " << norm(A*x-b) << endl;          // Check
    C=A.getSubMat(0,5,0,4); 
    x=linSolve(C,b);
    cout << "Over determined system: " << norm(C*x-b) << endl; // Check (min possible but not 0)
    C=A.getSubMat(0,4,0,5);
    x=linSolve(C,b.getSubVect(0,4));
    cout << "Minimum norm under determined system: " 
        << norm(C*x-b.getSubVect(0,4)) << " " << norm(x) << endl; // Check (min |x| possible but not 0)...

template<typename T>

Matrix multt	(	const Matrix< T > &	A,
		const Matrix< T > &	B
	)

friend

Matrix matrix product (variant)

Parameters

A	left operand
B	right operand

Returns: A * transpose(B)

A34=multt(A32,A42); // matrix * matrix^T

template<typename T>

T norm	(	const Matrix< T > &	A,
		char	type = `'F'`
	)

friend

Matrix norms.

Parameters

A	argument
type	norm choice: 'F' (default): frobenius (sqrt of sum of squares) '1': 1-norm (max column sum) 'I': infinity-norm (max row sum) 'M': max-norm (largest abs value)

Returns: norm

    a=norm(A);                           // frobenius norm
    a=norm(A,'1');                       // 1-norm
    a=norm(A,'I');                       // infinity-norm
    a=norm(A,'M');                       // max norm...

template<typename T>

Matrix operator*	(	T	x,
		const Matrix< T > &	B
	)

friend

Multiplies each element by a scalar

Parameters

x	The scalar
B	The Matrix

Returns: The result

C=2*A; // scalar * Matrix

template<typename T>

std::ostream& operator<<	(	std::ostream &	out,
		const Matrix< T > &	A
	)

friend

Writes to stream (size and values). Reimplemented from MultiArray: add newlines and iterates over j at fixed i (MultiArray would do the opposite).

Parameters

out	output stream
A	matrix to write

Returns: updated stream

ofstream out("tmp.txt"); // ASCII write

out << A << endl; // ...

template<typename T>

std::istream& operator>>	(	std::istream &	in,
		Matrix< T > &	A
	)

friend

Reads from stream (size and values). Reimplemented from MultiArray: add newlines and iterates over j at fixed i (MultiArray would do the opposite).

Parameters

in	input stream
A	matrix to write

Returns: updated stream

ifstream in("tmp.txt"); // ASCII read

in >> A; // ...

template<typename T>

Matrix pseudoInverse	(	const Matrix< T > &	A,
		T	tolrel = `0`
	)

friend

Pseudo-inverse using SVD

Parameters

A	matrix
tolrel	relative tolerance (under which a sing. value is considered nul)

Returns: pseudo-inverse

    x=pseudoInverse(A)*b;                                      // pseudo-inverse
    cout << "Pseudo inverse, square: " << norm(A*x-b) << endl; // Check it, square case
    C=A.getSubMat(0,5,0,4); 
    x=pseudoInverse(C)*b;
    cout << "Pseudo inverse, over determined: " << norm(C*x-b) << endl; // Check it, over determined case
    C=A.getSubMat(0,4,0,5);
    x=pseudoInverse(C)*b.getSubVect(0,4);
    cout << "Pseudo inverse, under determined: " 
        << norm(C*x-b.getSubVect(0,4)) << " " << norm(x) << endl;       // Check it, under determined case...

template<typename T>

bool QR	(	const Matrix< T > &	A,
		Matrix< T > &	Q,
		Matrix< T > &	R,
		bool	all = `false`
	)

friend

QR decomposition. A is MxN with M>=N. A=QR where:

Parameters

A	matrix
Q,R	output
all	false: Q is MxN with orthogonal columns and R is NxN upper triangular true: Q is MxM orthogonal and R is MxN with N first rows upper diagonal and M-N last rows nul.

    Matrix<T> Q,R;                        // QR decomposition
    QR(D,Q,R);
    cout << "QR " << norm(D-Q*R) << endl; // check thin QR
    QR(D,Q,R,true);
    cout << "QR " << norm(D-Q*R) << endl; // check full QR...

template<typename T>

T rcond ( const Matrix< T > & A )

friend

Reciprocal condition number in the 1-norm

Parameters

A argument

Returns: condition number

a=rcond(A); // reciprocal condition number

template<typename T>

void svd	(	const Matrix< T > &	A,
		Matrix< T > &	U,
		Vector< T > &	S,
		Matrix< T > &	Vt,
		bool	all = `false`
	)

friend

Singular value decomposition. A is MxN. S is of size min(M,N) with decreasing singular values. A=U*diag(S)*Vt where U (resp. Vt) is MxM (resp NxN) orthonormal, diag(S) is MxN with S as diagonal. If M<N (resp. M>N) then Vt (resp. U) is incompletely filled, except if all is true.

Parameters

A	matrix
U,S,Vt	SVD output
all	completely fill U and V (even columns multiplied by zero)

    Vector<T> S;                         // Singular value decomposition
    Matrix<T> U,Vt;
    svd(A,U,S,Vt);                           // square matrix
    cout << "SVD check 1: " 
        << norm(A-U*Diagonal(S)*Vt) << endl; // Check result
    svd(A34,U,S,Vt);                         // non square matrix
    cout << "SVD check 2: " 
         << norm(A34-U*Matrix<T>::Zero(3,4).setDiagonal(S)*Vt) << endl; // Check result
    svd(A34,U,S,Vt,true);                    // non square, complete U and Vt
    cout << "SVD check 3: " 
        << norm(Vt*transpose(Vt)-Matrix<T>::Identity(4)) << endl; // Check Vt...

See equivalent function for FMatrix.

template<typename T>

Vector<T> tmult	(	const Matrix< T > &	A,
		const Vector< T > &	v
	)

friend

Matrix vector product (variant)

Parameters

A	left operand
v	right operand

Returns: transpose(A)* v

v=tmult(A,w); // matrix^T * vector

template<typename T>

Matrix tmult	(	const Matrix< T > &	A,
		const Matrix< T > &	B
	)

friend

Matrix matrix product (variant)

Parameters

A	left operand
B	right operand

Returns: transpose(A) * B

A34=tmult(A23,A24); // matrix^T * matrix

template<typename T>

Matrix tmultt	(	const Matrix< T > &	A,
		const Matrix< T > &	B
	)

friend

Matrix matrix product (variant)

Parameters

A	left operand
B	right operand

Returns: transpose(A) * transpose(B)

A34=tmultt(A23,A42); // matrix^T * matrix^T

template<typename T>

Matrix transpose ( const Matrix< T > & A )

friend

Transposed matrix

Parameters

A argument

Returns: Transposed matrix

A=A*transpose(A); // transpose

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

/Users/pascal/ImagineQt2/Imagine/LinAlg/src/Imagine/LinAlg/Matrix.h

Public Types

Public Member Functions

Static Public Member Functions

Friends

Detailed Description

template<typename T> singleton Imagine::Matrix< T >

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

template<typename T>
singleton Imagine::Matrix< T >