RWHessEigServer< TypeT > Class Template Reference

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

#include <rw/lapack/eigsrv.h>

Inheritance diagram for RWHessEigServer< TypeT >:

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

Detailed Description

template<class TypeT>
class RWHessEigServer< TypeT >

The class RWHessEigServer encapsulates Hessenberg decomposition eigenvalue servers. These servers are used to construct eigenvalue decomposition objects of type RWEigDecomp 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>

Example

#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

RWHessEigServer() [1/2]

template<class TypeT >

RWHessEigServer< TypeT >::RWHessEigServer ( )

inline

Constructs a server. Use member functions to set basic options.

RWHessEigServer() [2/2]

template<class TypeT >

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

explicit

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

Member Function Documentation

balance()

template<class TypeT >

void RWHessEigServer< TypeT >::balance

(

bool

)

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

computeAllEigenVectors()

template<class TypeT >

bool RWHessEigServer< TypeT >::computeAllEigenVectors

(

)

const

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

computeLeftEigenVectors() [1/2]

template<class TypeT >

bool RWHessEigServer< TypeT >::computeLeftEigenVectors

(

)

const

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

computeLeftEigenVectors() [2/2]

template<class TypeT >

void RWHessEigServer< TypeT >::computeLeftEigenVectors

(

bool

)

Configures whether or not left eigenvectors are to be computed.

computeRightEigenVectors() [1/2]

template<class TypeT >

bool RWHessEigServer< TypeT >::computeRightEigenVectors

(

)

const

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

computeRightEigenVectors() [2/2]

template<class TypeT >

void RWHessEigServer< TypeT >::computeRightEigenVectors

(

bool

)

Configures whether or not right eigenvectors are to be computed.

operator()() [1/3]

template<class TypeT >

virtual RWEigDecomp< TypeT > RWHessEigServer< TypeT >::operator() ( const RWBalanceDecomp< TypeT > & A )

virtual

Computes an eigenvalue decomposition.

operator()() [2/3]

template<class TypeT >

virtual RWEigDecomp< TypeT > RWHessEigServer< TypeT >::operator() ( const RWGenMat< TypeT > & A )

virtual

Computes an eigenvalue decomposition.

Implements RWEigServer< TypeT >.

operator()() [3/3]

template<class TypeT >

virtual RWEigDecomp< TypeT > RWHessEigServer< TypeT >::operator() ( const RWHessenbergDecomp< TypeT > & A )

virtual

Computes an eigenvalue decomposition.

permute() [1/2]

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.

permute() [2/2]

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.

scale() [1/2]

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.

scale() [2/2]

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.

selectEigenVectors() [1/2]

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.

selectEigenVectors() [2/2]

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.