RWHessEigServer< TypeT > Class Template Reference
[Nonsymmetric Eigenvalue Decomposition]

Encapsulates Hessenberg decomposition eigenvalue servers used to construct eigenvalue decomposition objects of type RWEigDecomp<T> from Hessenberg decompositions. More...

#include <rw/lapack/eigsrv.h>

Inheritance diagram for RWHessEigServer< TypeT >:

List of all members.

Public Member Functions
	RWHessEigServer (bool computeLeftVecs=true, bool computeRightVecs=true, bool scale=true, bool permute=true)
virtual RWEigDecomp< TypeT >	operator() (const RWGenMat< TypeT > &A)
virtual RWEigDecomp< TypeT >	operator() (const RWBalanceDecomp< TypeT > &A)
virtual RWEigDecomp< TypeT >	operator() (const RWHessenbergDecomp< TypeT > &A)
bool	computeLeftEigenVectors () const
void	computeLeftEigenVectors (bool)
bool	computeRightEigenVectors () const
void	computeRightEigenVectors (bool)
bool	computeAllEigenVectors () const
bool	scale () const
void	scale (bool)
void	selectEigenVectors (const RWMathVec< int > &)
void	selectEigenVectors (const RWSlice &)
bool	permute () const
void	permute (bool)
void	balance (bool)

---

Detailed Description

template<class TypeT>
class RWHessEigServer< TypeT >

The class RWHessEigServer<T> encapsulates Hessenberg decomposition eigenvalue servers. These servers are used to construct eigenvalue decomposition objects of type RWEigDecomp<T> from Hessenberg decompositions. The server can be configured to control which eigenvectors are computed, and other details of the computation. The eigenvectors are computed using inverse iteration. This is a good method to use when you need only a small number of the eigenvectors, perhaps less than 20%.

Synopsis

 #include <rw/lapack/eigsrv.h>
 
 RWHessEigServer<double> server;
 RWHessEigDecomp<double> deig = server(A); // A is an
                                   // RWGenMat<double>

Examples

 #include <rw/lapack/eigsrv.h>
 #include <iostream>
 
 int main()
 {
     RWGenMat<double> A; // input a matrix
     std::cin >> A;
 
     RWHessEigServer<double> server; // configure a server
     server.balance(false); // turn off balancing option
     server.selectEigenVectors(RWMathVec<int>("[1 2 3 8 9]"));
     
     RWHessEigDecomp<double> deig = server(A);
     return 0;
 }

---

Constructor & Destructor Documentation

template<class TypeT>

RWHessEigServer< TypeT >::RWHessEigServer	(	bool	computeLeftVecs = true,
		bool	computeRightVecs = true,
		bool	scale = true,
		bool	permute = true
	)

Constructs a server. You can adjust some basic options at construction time, or adjust them later using member functions.

---

Member Function Documentation

template<class TypeT>

void RWHessEigServer< TypeT >::balance

(

bool

)

Controls whether to do permutation and scaling transformations (balancing) before computing the eigenvalue decomposition.

template<class TypeT>

bool RWHessEigServer< TypeT >::computeAllEigenVectors

(

)

const

Returns true if this server is configured to compute all the eigenvectors.

template<class TypeT>

void RWHessEigServer< TypeT >::computeLeftEigenVectors

(

bool

)

Configures whether or not left eigenvectors are to be computed.

template<class TypeT>

bool RWHessEigServer< TypeT >::computeLeftEigenVectors

(

)

const

Returns whether or not this server is configured to compute the left eigenvectors.

template<class TypeT>

void RWHessEigServer< TypeT >::computeRightEigenVectors

(

bool

)

Configures whether or not right eigenvectors are to be computed.

template<class TypeT>

bool RWHessEigServer< TypeT >::computeRightEigenVectors

(

)

const

Returns whether or not this server is configured to compute the right eigenvectors.

template<class TypeT>

virtual RWEigDecomp<TypeT> RWHessEigServer< TypeT >::operator()

(

const RWHessenbergDecomp< TypeT > &

A

)

[virtual]

Computes an eigenvalue decomposition.

template<class TypeT>

virtual RWEigDecomp<TypeT> RWHessEigServer< TypeT >::operator()

(

const RWBalanceDecomp< TypeT > &

A

)

[virtual]

Computes an eigenvalue decomposition.

template<class TypeT>

virtual RWEigDecomp<TypeT> RWHessEigServer< TypeT >::operator()

(

const RWGenMat< TypeT > &

A

)

[virtual]

Computes an eigenvalue decomposition.

Implements RWEigServer< TypeT >.

template<class TypeT>

void RWHessEigServer< TypeT >::permute

(

bool

)

Configures whether or not to do a permutation transformation before computing the eigenvalues. Sometimes this can result in less computation.

template<class TypeT>

bool RWHessEigServer< TypeT >::permute

(

)

const

Returns true if the server is configured to attempt a permutation before computing the eigenvalues. Sometimes this can result in less computation.

template<class TypeT>

void RWHessEigServer< TypeT >::scale

(

bool

)

Configures whether or not to do a scaling transformation before computing the eigenvalues. Sometimes this transformation can result in more accurate eigenvalues.

template<class TypeT>

bool RWHessEigServer< TypeT >::scale

(

)

const

Returns true if the server is configured to do a scaling transformation before computing the eigenvalues. Sometimes this transformation can result in more accurate eigenvalues.

template<class TypeT>

void RWHessEigServer< TypeT >::selectEigenVectors

(

const RWSlice &

)

Selects which eigenvectors are to be computed. This call causes the server to forget which eigenvectors were previously selected. With a real as opposed to complex eigenserver object, selecting either of a complex conjugate pair of eigenvalues causes both to be selected.

template<class TypeT>

void RWHessEigServer< TypeT >::selectEigenVectors

(

const RWMathVec< int > &

)

Selects which eigenvectors are to be computed. This call causes the server to forget which eigenvectors were previously selected. With a real as opposed to complex eigenserver object, selecting either of a complex conjugate pair of eigenvalues causes both to be selected.