RWSkewMat< TypeT > Class Template Reference
[Sparse Matrices]

Encapsulates skew symmetric matrices. More...

#include <rw/lapack/skewmat.h>

Public Member Functions
	RWSkewMat ()
	RWSkewMat (const RWSkewMat< TypeT > &A)
	RWSkewMat (unsigned n, unsigned nAgain)
	RWSkewMat (const RWMathVec< TypeT > &vd, unsigned n, unsigned nAgain)
	RWSkewMat (const RWSkewMat< double > &re, const RWSkewMat< double > &im)
unsigned	rows () const
unsigned	cols () const
TypeT	val (int i, int j) const
TypeT	bcval (int i, int j) const
TypeT	set (int i, int j, TypeT x)
TypeT	bcset (int i, int j, TypeT x)
RWNGRef< TypeT >	operator() (int i, int j)
RWNGRef< TypeT >	ref (int i, int j)
RWNGRef< TypeT >	bcref (int i, int j)
TypeT	operator() (int i, int j) const
RWSkewMat< TypeT >	leadingSubmatrix (int k)
RWSkewMat< TypeT > &	operator= (const RWSkewMat< TypeT > &A)
RWSkewMat< TypeT > &	reference (RWSkewMat< TypeT > &m)
void	zero ()
RWSkewMat< TypeT >	copy () const
RWSkewMat< TypeT >	deepCopy () const
void	deepenShallowCopy ()
const RWMathVec< TypeT > &	dataVec () const
TypeT *	data ()
void	resize (unsigned m, unsigned n)
void	scanFrom (std::istream &)
void	printOn (std::ostream &) const
void	restoreFrom (RWvistream &)
void	saveOn (RWvostream &) const
void	restoreFrom (RWFile &)
void	saveOn (RWFile &) const
unsigned	binaryStoreSize () const
bool	operator== (const RWSkewMat< TypeT > &X)
bool	operator!= (const RWSkewMat< TypeT > &X)
RWSkewMat< TypeT > &	operator+= (const RWSkewMat< TypeT > &m)
RWSkewMat< TypeT > &	operator-= (const RWSkewMat< TypeT > &m)
RWSkewMat< TypeT > &	operator*= (const RWSkewMat< TypeT > &m)
RWSkewMat< TypeT > &	operator*= (TypeT)
RWSkewMat< TypeT > &	operator/= (const RWSkewMat< TypeT > &m)
RWSkewMat< TypeT > &	operator/= (TypeT)
Related Functions
(Note that these are not member functions.)
template<class TypeT >
RWSkewMat< TypeT >	operator- (const RWSkewMat< TypeT > &)
template<class TypeT >
RWSkewMat< TypeT >	operator+ (const RWSkewMat< TypeT > &)
template<class TypeT >
RWSkewMat< TypeT >	operator* (const RWSkewMat< TypeT > &, const RWSkewMat< TypeT > &)
template<class TypeT >
RWSkewMat< TypeT >	operator/ (const RWSkewMat< TypeT > &, const RWSkewMat< TypeT > &)
template<class TypeT >
RWSkewMat< TypeT >	operator+ (const RWSkewMat< TypeT > &, const RWSkewMat< TypeT > &)
template<class TypeT >
RWSkewMat< TypeT >	operator- (const RWSkewMat< TypeT > &, const RWSkewMat< TypeT > &)
template<class TypeT >
RWSkewMat< TypeT >	operator* (const RWSkewMat< TypeT > &A, TypeT x)
template<class TypeT >
RWSkewMat< TypeT >	operator* (TypeT x, const RWSkewMat< TypeT > &A)
template<class TypeT >
RWSkewMat< TypeT >	operator/ (const RWSkewMat< TypeT > &A, TypeT x)
template<class TypeT >
RWSkewMat< TypeT >	operator/ (TypeT x, const RWSkewMat< TypeT > &A)
template<class TypeT >
std::ostream &	operator<< (std::ostream &s, const RWSkewMat< TypeT > &m)
template<class TypeT >
std::istream &	operator>> (std::istream &s, RWSkewMat< TypeT > &m)
template<class TypeT >
RWSkewMat< TypeT >	transpose (const RWSkewMat< TypeT > &)
template<class TypeT >
RWMathVec< TypeT >	product (const RWSkewMat< TypeT > &A, const RWMathVec< TypeT > &x)
template<class TypeT >
RWMathVec< TypeT >	product (const RWMathVec< TypeT > &x, const RWSkewMat< TypeT > &A)
template<class TypeT >
RWSkewMat< TypeT >	toSkewMat (const RWGenMat< TypeT > &A, bool keepMainDiag=true)
template<class TypeT >
RWSymMat< typename rw_numeric_traits< TypeT > ::norm_type >	abs (const RWSkewMat< TypeT > &A)
RWSkewMat< double >	real (const RWSkewMat< DComplex > &A)
RWSkewMat< double >	imag (const RWSkewMat< DComplex > &A)
RWSymMat< double >	norm (const RWSkewMat< DComplex > &A)

Detailed Description

template<class TypeT>
class RWSkewMat< TypeT >

The class RWSkewMat<T> encapsulates skew symmetric matrices. A skew symmetric matrix is defined by the requirement that A_ij = -A_ji. This strict definition implies that the diagonal entries must be 0. This requirement is relaxed by the Rogue Wave skew symmetric matrix classes, which require only that A_ij = -A_ji for the off-diagonal elements; in other words, the diagonal need not be 0. Skew symmetric matrices with nonzero diagonals are sometimes useful, for example, as rotation matrices in computer graphics applications.

Synopsis

 #include <rw/lapack/skewmat.h>
 
 RWSkewMat<double> A;

Example

 #include <rw/lapack/skewmat.h>
 
 int main()
 {
     RWSkewMat<float> T(3,3);
     RWMathVec<float> x(3);
     RWMathVec<float> Tx = product(T,x);
     return 0;
 }

Storage Scheme

The upper triangle of the matrix is stored in column major order. The lower triangle is then calculated implicitly.

$\begin{bmatrix} A_{11} & A_{12} & A_{12} & ... & A_{1n} \\ -A_{12} & A_{22} & A_{23} & ... & A_{2n} \\ -A_{13} & -A_{23} & A_{33} & ... & A_{3n} \\ . & & & & \\ . & & & & \\ . & & & & \\ A_{1n} & A_{2n} & A_{3n} & ... & A_{nn} \\ \end{bmatrix}$

The data is stored in the following order:

[ A₁₁ A₁₂ A₂₂ A₁₃ A₂₃ A₃₃ ... A_1n A_2n A_3n ... A_nn ]

The mapping between the array and storage vector is as follows:

$A(i + 1, j + 1) \to \left\{ \begin{array}{l l} \text{vec}[j(j+1)/ 2+i] & \quad \text{if } i \leq j \\ \text{-vec}[i(i+1)/ 2+j] & \quad \text{if } j \leq i \\ \end{array} \right.$

Constructor & Destructor Documentation

template<class TypeT>

RWSkewMat< TypeT >::RWSkewMat ( )

Default constructor. Builds a matrix of size 0 x 0. This constructor is necessary to declare a matrix with no explicit constructor or to declare an array of matrices.

template<class TypeT>

RWSkewMat< TypeT >::RWSkewMat ( const RWSkewMat< TypeT > & A )

Build a copy of its argument, A. Note that the new matrix references A's data. To construct a matrix with its own copy of the data, use either the copy() or deepenShallowCopy() member functions.

template<class TypeT>

RWSkewMat< TypeT >::RWSkewMat	(	unsigned	n,
		unsigned	nAgain
	)

Defines an uninitialized matrix of size n x nAgain. Both arguments must be equal or a runtime error occurs. This constructor is used, rather than a constructor that takes only a single argument, to avoid type conversion problems.

template<class TypeT>

RWSkewMat< TypeT >::RWSkewMat	(	const RWMathVec< TypeT > &	vd,
		unsigned	n,
		unsigned	nAgain
	)

Constructs a size n x nAgain matrix using the data in the passed vector. Arguments n and nAgain must be equal or a runtime error occurs. This data must be stored in the format described in the Storage Scheme section. The resultant matrix references the data in vector vd.

template<class TypeT>

RWSkewMat< TypeT >::RWSkewMat	(	const RWSkewMat< double > &	re,
		const RWSkewMat< double > &	im
	)

Constructs a complex matrix from the real and imaginary parts supplied.

Note:: the imaginary part of a complex skew-symmetric matrix is symmetric, not skew-symmetric.

Member Function Documentation

template<class TypeT>

RWNGRef<TypeT> RWSkewMat< TypeT >::bcref	(	int	i,
		int	j
	)

Returns a reference to the ij ^th element of the matrix, after doing bounds checking.

template<class TypeT>

TypeT RWSkewMat< TypeT >::bcset	(	int	i,
		int	j,
		TypeT	x
	)

Sets the ij ^th element of the matrix equal to x, after doing bounds checking.

template<class TypeT>

TypeT RWSkewMat< TypeT >::bcval	(	int	i,
		int	j
	)			const

Returns the value of the ij ^th element of the matrix, after doing bounds checking.

template<class TypeT>

unsigned RWSkewMat< TypeT >::binaryStoreSize ( ) const

Returns the number of bytes that it would take to write the matrix to a file using saveOn().

template<class TypeT>

unsigned RWSkewMat< TypeT >::cols ( ) const [inline]

Returns the number of columns in the matrix.

template<class TypeT>

RWSkewMat<TypeT> RWSkewMat< TypeT >::copy ( ) const

Creates a copy of this matrix with distinct data. The stride of the data vector in the new matrix is guaranteed to be 1.

template<class TypeT>

TypeT* RWSkewMat< TypeT >::data ( void ) [inline]

Returns a pointer to the first item of data in the vector storing the matrix's data. You can use this (with caution!) to pass the matrix's data to C or FORTRAN subroutines. Be aware that the stride of the data vector may not be 1.

template<class TypeT>

const RWMathVec<TypeT>& RWSkewMat< TypeT >::dataVec ( ) const [inline]

Returns the matrix's data vector. This is where the explicitly stored entries in the matrix are kept.

template<class TypeT>

RWSkewMat<TypeT> RWSkewMat< TypeT >::deepCopy ( ) const [inline]

Creates a copy of this matrix with distinct data. The stride of the data vector in the new matrix is guaranteed to be 1.

template<class TypeT>

void RWSkewMat< TypeT >::deepenShallowCopy ( ) [inline]

Ensures that the data in the matrix is not shared by any other matrix or vector. Also ensures that the stride in the data vector is equal to 1. If necessary, a new copy of the data vector is made.

template<class TypeT>

RWSkewMat<TypeT> RWSkewMat< TypeT >::leadingSubmatrix ( int k )

Returns the k x k upper left corner of the matrix. The submatrix and the matrix share the same data.

template<class TypeT>

bool RWSkewMat< TypeT >::operator!= ( const RWSkewMat< TypeT > & X ) [inline]

Two matrices are considered equal if they have the same size and their elements are all exactly the same. Be aware that floating point arithmetic is not exact; matrices that are theoretically equal are not always numerically equal.

template<class TypeT >

TypeT RWSkewMat< TypeT >::operator()	(	int	i,
		int	j
	)			const `[inline]`

Accesses the ij ^th element. Using this operator is equivalent to calling the val() member function. Bounds checking is done if the preprocessor symbol RWBOUNDS_CHECK is defined before including the header file.

template<class TypeT >

RWNGRef< TypeT > RWSkewMat< TypeT >::operator()	(	int	i,
		int	j
	)			`[inline]`

References the ij ^th element. This operator is equivalent to calling the ref() member function. Bounds checking is done if the preprocessor symbol RWBOUNDS_CHECK is defined before including the header file.

template<class TypeT>

RWSkewMat<TypeT>& RWSkewMat< TypeT >::operator*= ( TypeT )

Performs the indicated operation on each element of the matrix.

template<class TypeT>

RWSkewMat<TypeT>& RWSkewMat< TypeT >::operator*= ( const RWSkewMat< TypeT > & m )

Performs element-by-element arithmetic on the data in the matrices.

Note:: operator*=() does element-by-element multiplication, not inner-product style matrix multiplication. You can use the product() global function to do matrix-matrix inner product multiplication.

template<class TypeT>

RWSkewMat<TypeT>& RWSkewMat< TypeT >::operator+= ( const RWSkewMat< TypeT > & m )

Performs element-by-element arithmetic on the data in the matrices.

template<class TypeT>

RWSkewMat<TypeT>& RWSkewMat< TypeT >::operator-= ( const RWSkewMat< TypeT > & m )

Performs element-by-element arithmetic on the data in the matrices.

template<class TypeT>

RWSkewMat<TypeT>& RWSkewMat< TypeT >::operator/= ( TypeT )

Performs the indicated operation on each element of the matrix.

template<class TypeT>

RWSkewMat<TypeT>& RWSkewMat< TypeT >::operator/= ( const RWSkewMat< TypeT > & m )

Performs element-by-element arithmetic on the data in the matrices.

template<class TypeT>

RWSkewMat<TypeT>& RWSkewMat< TypeT >::operator= ( const RWSkewMat< TypeT > & A )

Sets the matrix elements equal to the elements of A. The two matrices must be the same size. To make the matrix reference the same data as A, use the reference member function.

template<class TypeT>

bool RWSkewMat< TypeT >::operator== ( const RWSkewMat< TypeT > & X )

Two matrices are considered equal if they have the same size and their elements are all exactly the same. Be aware that floating point arithmetic is not exact; matrices that are theoretically equal are not always numerically equal.

template<class TypeT>

void RWSkewMat< TypeT >::printOn ( std::ostream & ) const

Prints the matrix to an output stream in human readable format.

template<class TypeT >

RWNGRef< TypeT > RWSkewMat< TypeT >::ref	(	int	i,
		int	j
	)			`[inline]`

Returns a reference to the ij ^th element of the matrix. Bounds checking is done if the preprocessor symbol RWBOUNDS_CHECK is defined when the header file is read. The member function bcref() does the same thing with guaranteed bounds checking.

template<class TypeT>

RWSkewMat<TypeT>& RWSkewMat< TypeT >::reference ( RWSkewMat< TypeT > & m )

Makes this matrix a reference to the argument matrix. The two matrices share the same data. The matrices do not have to be the same size before calling reference(). To copy a matrix into another of the same size, use the operator=() member operator.

template<class TypeT>

void RWSkewMat< TypeT >::resize	(	unsigned	m,
		unsigned	n
	)

Resizes the matrix. Any new entries in the matrix are set to 0. Both arguments must be the same.

template<class TypeT>

void RWSkewMat< TypeT >::restoreFrom ( RWFile & )

Reads in a matrix from an RWFile. The matrix must have been stored to the file using the saveOn() member function.

template<class TypeT>

void RWSkewMat< TypeT >::restoreFrom ( RWvistream & )

Reads in a matrix from an RWvistream, the Rogue Wave virtual input stream class. The matrix must have been stored to the stream using the saveOn() member function.

template<class TypeT>

unsigned RWSkewMat< TypeT >::rows ( ) const [inline]

Returns the number of rows in the matrix.

template<class TypeT>

void RWSkewMat< TypeT >::saveOn ( RWFile & ) const

Stores a matrix to an RWFile. The matrix can be read using the restoreFrom() member function.

template<class TypeT>

void RWSkewMat< TypeT >::saveOn ( RWvostream & ) const

Stores a matrix to an RWvostream, the Rogue Wave virtual output stream class. The matrix can be read using the restoreFrom() member function.

template<class TypeT>

void RWSkewMat< TypeT >::scanFrom ( std::istream & )

Reads a matrix from an input stream. The format of the matrix is the same as the format output by the printOn() member function. Below is a sample matrix that could be input. Note that extra white space and any text preceding the dimension specification are ignored. Only the skew symmetric part of the matrix is used.

 3x3  [  4    5    7
        -5    9    5
        -7  -5     3  ]

template<class TypeT >

TypeT RWSkewMat< TypeT >::set	(	int	i,
		int	j,
		TypeT	x
	)			`[inline]`

Sets the ij ^th element of the matrix equal to x. Bounds checking is done if the preprocessor symbol RWBOUNDS_CHECK is defined when the header file is read. The member function bcset() does the same thing with guaranteed bounds checking.

template<class TypeT >

TypeT RWSkewMat< TypeT >::val	(	int	i,
		int	j
	)			const `[inline]`

Returns the value of the ij ^th element of the matrix. Bounds checking is done if the preprocessor symbol RWBOUNDS_CHECK is defined when the header file is read. The member function bcval() does the same thing with guaranteed bounds checking.

template<class TypeT>

void RWSkewMat< TypeT >::zero ( ) [inline]

Sets every element of the matrix to 0.

Friends And Related Function Documentation

template<class TypeT >

RWSymMat< typename rw_numeric_traits< TypeT >::norm_type > abs ( const RWSkewMat< TypeT > & A ) [related]

Returns a matrix whose entries are the absolute value of the argument. The absolute value of a complex number is considered to be the sum of the absolute values of its real and imaginary parts. To get the norm of a complex matrix, you can use the norm() function.

template<class TypeT>

RWSkewMat< double > imag ( const RWSkewMat< DComplex > & A ) [related]

Returns a matrix where each element is the imaginary part of the corresponding element in the matrix A.

template<class TypeT>

RWSymMat< double > norm ( const RWSkewMat< DComplex > & A ) [related]

Returns a matrix where each element is the norm (magnitude) of the corresponding element in the matrix A.

template<class TypeT >

RWSkewMat< TypeT > operator*	(	TypeT	x,
		const RWSkewMat< TypeT > &	A
	)			`[related]`