C++ Code Documentation | template <class A, uint N> math::MatrixX

Index

C++ Code Documentation

template <class A, uint N> math::MatrixX

File: BASE/math/MatrixX.H

Template matrix container class.

public:

MatrixX();

void constructor
MatrixX( MatrixX<A,N> const & );

copy constructor
MatrixX( A const *a );

constructor
~MatrixX();

destructor
MatrixX<A,N> & operator=( MatrixX<A,N> const & );

assignment operators
MatrixX<A,N> & operator=( A const *a );
A * operator[]( uint );

reference to entry
A const * operator[]( uint ) const;

reference to entry
void zero();

set all entries of *this to 0
void clear();

set all entries of *this to 0
void set( A const & );

set all entries of *this to a
void identity();

*this := identity MatrixX
void getrow( VectorX<A, N> &, uint ) const;

copy nth row of *this into a
void getcol( VectorX<A, N> &, uint ) const;

copy nth column of *this into a
void putrow( VectorX<A, N> const &, uint );

copy a into nth row of *this
void putcol( VectorX<A, N> const &, uint );

copy a into nth column of *this
void neg();

negation: *this := - *this
void neg( MatrixX<A,N> const & );

negation *this := -a
void add( MatrixX<A,N> const &, MatrixX<A,N> const &b );

*this := a + b
void add( MatrixX<A,N> const &a );

*this += a
void operator+=( MatrixX<A,N> const &a );

*this += a
void sub( MatrixX<A,N> const &, MatrixX<A,N> const & );

*this := a - b
void sub( MatrixX<A,N> const &a );

*this -= a
void operator-=( MatrixX<A,N> const &a );

*this -= a
void operator*=( A const & );

*this *= a
void operator*=( MatrixX<A,N> const & );

*this *= a
void mul( A const &, MatrixX<A,N> const &b );

scalar multiplication: *this := a * b
void mul( MatrixX<A,N> const &, A const &b );

scalar multiplication: *this := a * b
void mul( A const &b );

scalar multiplication: *this *= a
void mul( VectorX<A,N> &v ) const;

vector multiplication v := (*this) * v
void mulleft( VectorX<A,N> &v ) const;

vector multiplication v := v * (*this)
void mul( MatrixX<A,N> const &, MatrixX<A,N> const &b );

matrix multiplication: *this := a * b
void mul( MatrixX<A,N> const &a );

matrix multiplication: *this *= a
void mulleft( MatrixX<A,N> const &a );

matrix multiplication: *this *= a
void operator/=( A const & );

*this /= a
void div( MatrixX<A,N> const &, A const &b );

*this := a / b
A trace() const;

return trace( *this )
void transpose();

*this := transpose( *this )
void transpose( MatrixX<A,N> const & );

*this := transpose( a )
friend std::ostream & operator<< NULL_TMPL_ARGS ( std::ostream &o, MatrixX<A,N> const & );

write a to stream o

int linear_solve( VectorX<A,N> &B );

	solves the linear system A.X=B. A: n-by-n matrix of A's (already allocated) (input and output) n: size of a (input) B: right-hand-side and and solution (input and output) A is replaced by its LU-decomposition

int inv();

computes the inverse of a matrix. A_inv: inverse of A (already allocated) (output) A: n-by-n matrix of A's (already allocated) (input) n: size of a (input)
int inv( MatrixX<A,N> const & );
A det() const;

int LU_decomposition(VectorX<uint,N> &indx, int &d);

	replaces a by LU-decomposition. With pivoting. a: n-by-n matrix of A's (already allocated) (input and output) n: size of a (input) indx: row permutation index (already allocated) (output) d: +1 or -1 according as permuation is even/odd (output) a and a_inv must be distinct

int LU_back_substitution( VectorX<uint,N> const &indx, VectorX<A,N> &b );

LU_back_substitution. a: n-by-n matrix of A's in LU form (input) n: size of a (input) indx: row permutation index (already allocated) (input) b: right-hand-side (array of n A's) (input and output)
A *data();

protected:

A _data[N][N];

The elements x[][] sit in memory in the order x[0][0],..., x[0][N-1], x[1][0],....

private:

template <class A, uint N> math::MatrixX

GANG