RWHermMat<T>

Module:  Linear Algebra   Group:  Sparse Matrix classes

Does not inherit

• Local Index
• Synopsis
• Description
• Example
• Storage Scheme
• Public Constructors
• Public Member Functions
• Public Member Operators
• Global Operators
• Global Functions

Members

bcref() bcset() bcval() binaryStoreSize() cols() copy() data() dataVec()

deepCopy() deepenShallowCopy() leadingSubmatrix() makeDiagonalReal() operator!=() operator*=() operator+=() operator-=()

operator/=() operator=() operator==() printOn() ref() reference() resize() restoreFrom()

rows() RWHermMat<T>::operator() RWHermMat() saveOn() scanFrom() set() val() zero()

Non-Members

abs() arg() conj() imag() lowerToHermMat()

norm() operator>>() operator<<() operator*() operator+()

operator-() operator/() product() real() toHermBandMat()

transpose() upperToHermMat()

#include <rw/lapack/hermmat.h>

RWHermMat<T> H;

The class RWHermMat<T> encapsulates a Hermitian matrix. A Hermitian matrix is defined by the requirement that A_ij = conj(A_ji). This strict definition implies that the diagonal elements have 0 imaginary parts. The Rogue Wave classes relax this definition along the diagonal so that diagonal elements can have nonzero imaginary parts.

#include <rw/lapack/hermmat.h>
#include <rw/lapack/symmat.h>
#include <rw/lapack/skewmat.h>

int main()
{
  RWHermMat<T> H(4,4);
  RWSymMat<double> Hreal = real(H);
  RWSkewMat<double> Himag = imag(H);
  return 0;
}

The upper triangle of the matrix is stored in column major order. The lower triangle is then calculated implicitly. The upper triangle is stored in column major order. This storage scheme is used so that the leading part of the matrix is always located in contiguous memory.

For example, given the following matrix:

the data is stored in the following order:

[ A11 A12 A22 A13 A23 A33 ... A1n A2n A3n ... Ann ]

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

RWHermMat();

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.

RWHermMat(const RWHermMat<T>& A);

Builds 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, you can use either the copy or deepenShallowCopy member functions.

RWHermMat(unsigned n, unsigned n);

Defines an uninitialized matrix of size n x n. Both arguments must be equal or a runtime error occurs.

RWHermMat(const RWMathVec<T>& vd, unsigned n,unsigned
          n);

Constructs a size n x n matrix using the data in the passed vector. This data must be stored in the format described in the Storage Scheme section. The resultant matrix references the data in vector vd.

RWHermMat(const RWSymMat<double>& re);
RWHermMat(const RWSymMat<double>& re, 
          const RWSkewMat<double>& im);

Constructs a complex matrix from the real and imaginary parts supplied. If no imaginary part is supplied, the imaginary part is assumed to be 0.

DComplexRef
bcref(int i, int j);

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

void
bcset(int i, int j, DComplex x);

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

T
bcval(int i, int j);

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

unsigned
binaryStoreSize();

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

unsigned
cols();

Returns the number of columns in the matrix.

RWHermMat<T>
copy();

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

T*
data();

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

RWMathVec<T>
dataVec();

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

RWHermMat<T>
deepCopy();

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

void
deepenShallowCopy();

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.

RWHermMat<T>
leadingSubmatrix(int k);

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

void
makeDiagonalReal();

Sets the imaginary part of the main diagonal to 0, thus ensuring that the matrix satisfies the strict mathematical definition of Hermitian.

void
printOn(ostream&);

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

CJDComplexRef
ref(int i, int j);

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

RWHermMat<T>
reference(DComplexHermMat&);

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.

void
resize(unsigned n, unsigned n);

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

void
restoreFrom(RWFile&);

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

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

unsigned
rows();

Returns the number of rows in the matrix.

void
saveOn(RWFile&);

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

void
saveOn(RWvostream&);

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

void
scanFrom(istream&);

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

    3x3 
    [ (4,2)  (5,2)  (7,8) 
      (5,-2) (9,2)  (5,3)
      (7,-8) (5,-3) (3,0) 
    ]

void
set(int i, int j, DComplex x);

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

T
val(int i, int j);

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

RWHermMat<T>
zero();

Sets every element of the matrix to 0.

RWCJRef<T> RWHermMat<T>::operator()(int i, int j);
T          RWHermMat<T>::operator()(int i, int j)
              const;

Accesses the ij^th element. If the matrix is not a const matrix, a reference type is returned, so this operator can be used for assigning or accessing an element. In this case, using this operator is equivalent to calling the ref member function. If the matrix is a const matrix, a value is returned, so this operator can be used only for accessing an element. In this case, using this operator is equivalent to calling the val member function. Bounds checking is done if the preprocessor symbol BOUNDS_CHECK is defined before including the header file.

RWHermMat<T>&    operator=(const RWHermMat<T>& 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, you can use the reference member function.

RWHermMat<T>&    operator==(const RWHermMat<T>& A);
RWHermMat<T>&    operator!=(const RWHermMat<T>& A);

Boolean operators. 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, so matrices that are theoretically equal are not always numerically equal.

RWHermMat<T>&    operator*=(T x);
RWHermMat<T>&    operator/=(T x);

Performs the indicated operation on each element of the matrix.

RWHermMat<T>&    operator+=(const RWHermMat<T>& A);
RWHermMat<T>&    operator-=(const RWHermMat<T>& A);
RWHermMat<T>&    operator*=(const RWHermMat<T>& A);
RWHermMat<T>&    operator/=(const RWHermMat<T>& A);

Performs element-by-element arithmetic on the data in the matrices. In particular, note that 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.

RWHermMat<T>    operator+(const RWHermMat<T>&);
RWHermMat<T>    operator-(const RWHermMat<T>&);

Unary plus and minus operators. Each operator returns a copy of the matrix or its negation.

RWHermMat<T>    operator+(const RWHermMat<T>&, 
                     const RWHermMat<T>&);
RWHermMat<T>    operator-(const RWHermMat<T>&, 
                     const RWHermMat<T>&);
RWHermMat<T>    operator*(const RWHermMat<T>&, 
                     const RWHermMat<T>&);
RWHermMat<T>    operator/(const RWHermMat<T>&, 
                     const RWHermMat<T>&);

Performs element-by-element operations on the arguments. To do inner product matrix multiplication, use the product global function.

RWHermMat<T>   operator*(T, const RWHermMat<T>&);
RWHermMat<T>   operator*(const RWHermMat<T>&, T);
RWHermMat<T>   operator/(T, const RWHermMat<T>&);
RWHermMat<T>   operator/(const RWHermMat<T>&, T);

Performs element-by-element operations on the arguments.

ostream&    operator<<(ostream& s, const
                       RWHermMat<T>&);

Writes the matrix to the stream. This is equivalent to calling the printOn member function.

istream&    operator>>(istream& s, const
                       RWHermMat<T>&);

Reads the matrix from the stream. This is equivalent to calling the scanFrom member function.

RWSymMat<double>
abs(const RWHermMat<T>& A);

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.

RWSkewMat<double>
arg(const RWHermMat<T>& A);

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

RWHermMat<T>
conj(const RWHermMat<T>& A);

Returns a matrix where each element is the complex conjugate of the corresponding element in the matrix A.

RWSkewMat<double>
imag(const RWHermMat<T>& A);

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

RWHermMat<T>
lowerToHermMat(const RWGenMat<T>& A);

Builds a Hermitian matrix that matches the lower triangular part of A. The upper triangle of A is not referenced.

RWSymMat<double>
norm(const RWHermMat<T>& A);

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

RWMathVec<T>
product(const RWHermMat<T>& A, 
        const RWMathVec<T>& x);

Returns the inner product (matrix-vector product) of A and x.

RWMathVec<T>
product(const RWMathVec<T>& x, 
        const RWHermMat<T>& A);

Returns the inner product (matrix-vector product) of x and A. This is equal to the product of A transpose and x.

RWSymMat<double>
real(const RWHermMat<T>& A);

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

RWHermMat<T>
toHermBandMat(const RWGenMat<T>&, unsigned h);

Extracts the Hermitian part of a band of entries from a square matrix. The main diagonal is extracted, along with h subdiagonals and superdiagonals. If B is this band, the Hermitian part of the band is (B+conj(B^T))/2.

RWHermMat<T>
transpose(const RWHermMat<T>&);

Returns the transpose of the argument matrix.

RWHermMat<T>
upperToHermMat(const RWGenMat<T>& A);

Builds a Hermitian matrix that matches the upper triangular part of A. The lower triangle of A is not referenced.

© Copyright Rogue Wave Software, Inc. All Rights Reserved.
Rogue Wave and SourcePro are registered trademarks of Rogue Wave Software, Inc. in the United States and other countries. All other trademarks are the property of their respective owners.
Contact Rogue Wave about documentation or support issues.