STK::lapack::SymEigen< SquareArray > Class Template Reference

{ More...

#include <STK_lapack_SymEigen.h>

Inheritance diagram for STK::lapack::SymEigen< SquareArray >:

Public Types
typedef ISymEigen< SymEigen< SquareArray > >	Base

Public Member Functions
	SymEigen ()
	Default Constructor.
	SymEigen (SquareArray const &data, bool ref=false)
	Constructor.
template<class Derived >
	SymEigen (ArrayBase< Derived > const &data)
	Constructor.
	SymEigen (SymEigen const &eigen)
	copy constructor
virtual	~SymEigen ()
	Destructor.
void	setJobz (char jobz)
void	setRange (char range)
void	setUplo (char uplo)
void	setVlAndVu (Real const &vl, Real const &vu)
void	setIlAndIu (int il, int iu)
virtual SymEigen *	clone () const
	clone pattern
bool	runImpl ()
	Run eigenvalues decomposition Launch SYEVR LAPACK routine to perform the eigenvalues decomposition.
	SymEigen (CSquareX const &data, bool ref)
Public Member Functions inherited from STK::ISymEigen< SymEigen< SquareArray > >
	~ISymEigen ()
	virtual destructor
ISymEigen &	operator= (ISymEigen const &eigen)
	Operator = : overwrite the ISymEigen with eigen.
Range const &	range () const
Type const &	norm () const
int const &	rank () const
Type const &	det () const
Type const &	trace () const
CArraySquare< Type, size_ > const &	rotation () const
CArraySquare< Type, size_ > const &	eigenVectors () const
CArrayVector< Type, size_ > const &	eigenValues () const
void	setData (ExprBase< OtherDerived > const &data)
	overloading of setData.
ArraySquare &	ginv (ArraySquare &res) const
	Compute the generalized inverse of the symmetric matrix and put the result in res.
ArraySquare &	ginvsqrt (ArraySquare &res) const
	Compute the generalized square root inverse of the symmetric matrix and put the result in res.
ArraySquare &	gsqrt (ArraySquare &res) const
	Compute the square root of the symmetric matrix and put the result in res.
virtual bool	run ()
	Find the eigenvalues and eigenvectors of the matrix.
Public Member Functions inherited from STK::IRunnerBase
String const &	error () const
	get the last error message.
Public Member Functions inherited from STK::IRecursiveTemplate< Derived >
Derived &	asDerived ()
	static cast : return a reference of this with a cast to the derived class.
Derived const &	asDerived () const
	static cast : return a const reference of this with a cast to the derived class.
Derived *	asPtrDerived ()
	static cast : return a ptr on a Derived of this with a cast to the derived class.
Derived const *	asPtrDerived () const
	static cast : return a ptr on a constant Derived of this with a cast to the derived class.
Derived *	clone () const
	create a leaf using the copy constructor of the Derived class.
Derived *	clone (bool isRef) const
	create a leaf using the copy constructor of the Derived class and a flag determining if the clone is a reference or not.

Private Attributes
char	jobz_
	Lapack pptions.
char	RANGE_
char	UPLO_
Real	VL_
Real	VU_
int	IL_
int	IU_

Additional Inherited Members
Protected Types inherited from STK::ISymEigen< SymEigen< SquareArray > >
enum
typedef IRunnerBase	Base
typedef hidden::AlgebraTraits< SymEigen< SquareArray > >::SquareArray	SquareArray
typedef hidden::Traits< SquareArray >::Type	Type
Protected Member Functions inherited from STK::ISymEigen< SymEigen< SquareArray > >
	ISymEigen ()
	Default constructor.
	ISymEigen (SquareArray const &data, bool ref=false)
	Constructor The original data set can be overwritten by the eigenvectors if it is stored in a CSquareXd.
	ISymEigen (ExprBase< OtherDerived > const &data)
	template constructor
	ISymEigen (ISymEigen const &eigen)
	Copy constructor.
void	finalizeStep ()
	finalize the computation by computing the trace, rank, trace norm and determinant of the matrix.
Protected Member Functions inherited from STK::IRunnerBase
	IRunnerBase ()
	default constructor
	IRunnerBase (IRunnerBase const &runner)
	copy constructor
virtual	~IRunnerBase ()
	destructor
virtual void	update ()
	update the runner.
Protected Member Functions inherited from STK::IRecursiveTemplate< Derived >
	IRecursiveTemplate ()
	constructor.
	~IRecursiveTemplate ()
	destructor.
Protected Attributes inherited from STK::ISymEigen< SymEigen< SquareArray > >
Range	range_
	range of the original data set.
Type	trace_
	trace norm
Type	norm_
	trace norm
int	rank_
	rank
Type	det_
	determinant
CArraySquare< Type, size_ >	eigenVectors_
	Square matrix or the eigenvectors.
CArrayVector< Type, size_ >	eigenValues_
	Array of the eigenvalues.
CVectorXi	SupportEigenVectors_
	Array for the support of the eigenvectors.
Protected Attributes inherited from STK::IRunnerBase
String	msg_error_
	String with the last error message.
bool	hasRun_
	true if run has been used, false otherwise

Detailed Description

template<class SquareArray>
class STK::lapack::SymEigen< SquareArray >

{

SymEigen computes the eigenvalues and optionally the eigenvectors of a symmetric real matrix using the syevr Lapack routine.

The decomposition of a symmetric matrix require

• Input: A symmetric matrix A of size (n,n)
• Output:
  1. P Array of size (n,n).
  2. D Vector of dimension n
  3. The matrix A can be copied or overwritten by the class.

The 2-norm (operator norm) of the matrix is given. if the 2-norm is less than the arithmetic precision of the type Real, the rank is not full. Thus the user can be faced with a deficient rank matrix and with a norm and a determinant very small (but not exactly 0.0).

Note

Default values for syevr lapack parameters are

jobz_ = 'V'; RANGE_ = 'A'; UPLO_ = 'U';
 VL_ = 0.0; VU_ = 0.0; IL_ = 0; IU_ = 0;

See also

STK::ISymEigen, STK::SymEigen

Definition at line 97 of file STK_lapack_SymEigen.h.

Member Typedef Documentation

Base

template<class SquareArray >

typedef ISymEigen< SymEigen<SquareArray> > STK::lapack::SymEigen< SquareArray >::Base

Definition at line 100 of file STK_lapack_SymEigen.h.

Constructor & Destructor Documentation

SymEigen() [1/5]

template<class SquareArray >

STK::lapack::SymEigen< SquareArray >::SymEigen

(

)

Default Constructor.

Definition at line 182 of file STK_lapack_SymEigen.h.

                               : Base()
                                 , jobz_('V'), RANGE_('A'), UPLO_('U')
                                 , VL_(0.0), VU_(0.0), IL_(0), IU_(0)
{}

Referenced by STK::lapack::SymEigen< SquareArray >::clone().

SymEigen() [2/5]

template<class SquareArray >

STK::lapack::SymEigen< SquareArray >::SymEigen	(	SquareArray const &	data,
		bool	ref = false
	)

Constructor.

Parameters

data	reference on a symmetric square matrix
ref	true if we overwrite the data set, false otherwise

Note

data can be a reference if and only if it is a CSquareX

Default values for syevr lapack parameters are

jobz_ = 'V'; RANGE_ = 'A'; UPLO_ = 'U';
 VL_ = 0.0; VU_ = 0.0; IL_ = 0; IU_ = 0;

Definition at line 191 of file STK_lapack_SymEigen.h.

                              : Base(data)
                               , jobz_('V'), RANGE_('A'), UPLO_('U')
                               , VL_(0.0), VU_(0.0), IL_(0), IU_(0)
{}

SymEigen() [3/5]

template<class SquareArray >

template<class Derived >

STK::lapack::SymEigen< SquareArray >::SymEigen

(

ArrayBase< Derived > const &

data

)

Constructor.

Parameters

data	reference on a symmetric square expression

Definition at line 209 of file STK_lapack_SymEigen.h.

                              : Base(data)
                               , jobz_('V'), RANGE_('A'), UPLO_('U')
                               , VL_(0.0), VU_(0.0), IL_(0), IU_(0)
{}

SymEigen() [4/5]

template<class SquareArray >

STK::lapack::SymEigen< SquareArray >::SymEigen

(

SymEigen< SquareArray > const &

eigen

)

copy constructor

Parameters

eigen

the SymEigen to copy

Definition at line 218 of file STK_lapack_SymEigen.h.

                              : Base(eigen)
                               , jobz_(eigen.jobz_), RANGE_(eigen.RANGE_), UPLO_(eigen.UPLO_)
                               , VL_(eigen.VL_), VU_(eigen.VU_), IL_(eigen.IL_), IU_(eigen.IU_)
 {}

~SymEigen()

template<class SquareArray >

virtual STK::lapack::SymEigen< SquareArray >::~SymEigen ( )

inlinevirtual

Destructor.

Definition at line 131 of file STK_lapack_SymEigen.h.

{}

SymEigen() [5/5]

STK::lapack::SymEigen< CSquareX >::SymEigen ( CSquareX const &  data, bool  ref  )

inline

Definition at line 201 of file STK_lapack_SymEigen.h.

                                  : Base(data, ref)
                                   , jobz_('V'), RANGE_('A'), UPLO_('U')
                                   , VL_(0.0), VU_(0.0), IL_(0), IU_(0)
{}

Member Function Documentation

clone()

template<class SquareArray >

virtual SymEigen * STK::lapack::SymEigen< SquareArray >::clone ( ) const

inlinevirtual

clone pattern

Definition at line 163 of file STK_lapack_SymEigen.h.

{ return new SymEigen(*this);}

References STK::lapack::SymEigen< SquareArray >::SymEigen().

runImpl()

template<class SquareArray >

bool STK::lapack::SymEigen< SquareArray >::runImpl

(

)

Run eigenvalues decomposition Launch SYEVR LAPACK routine to perform the eigenvalues decomposition.

Returns

true if no error occur, false otherwise

Definition at line 229 of file STK_lapack_SymEigen.h.

{
#ifdef STK_ALGEBRA_VERY_VERBOSE
  stk_cout << _T("Enter in SymEigen::run\n");
#endif
  /* copy square matrix with the original data set. */
  CSquareX data_ = eigenVectors_;
  // shift data sets
  data_.shift(0);
  eigenVectors_.shift(0);
  eigenValues_.shift(0);
  this->SupportEigenVectors_.shift(0);
  /* set default behavior */
  Real absTol = 0.0; // let Lapack chose the correct tolerance
  // get optimal size necessary for work
  Real work; // work is just one place, get the optimal size for work
  // iwork is just on place, get the optimal size for iWork
  int iwork, lWork =-1, liwork =-1; // workspace variable
 
  int info = 1;
#ifdef STK_ALGEBRA_DEBUG
  stk_cout << _T("Data dimensions: ") << data_.rows() << " " << data_.cols() << "\n";
  stk_cout << _T("eigenValues_ dimensions: ") << eigenValues_.rows() << " " << eigenValues_.cols() << "\n";
  stk_cout << _T("eigenVectors_ dimensions: ") << eigenVectors_.rows() << " " << eigenVectors_.cols() << "\n";
  stk_cout << _T("Options: ") << jobz_ << " " << RANGE_ << " " << UPLO_ << "\n";
#endif
  info = syevr( jobz_, RANGE_, UPLO_
              , range_.size(), data_.p_data(), range_.size()
              , VL_, VU_, IL_, IU_
              , absTol, &rank_,  eigenValues_.p_data()
              , eigenVectors_.p_data(), range_.size(), this->SupportEigenVectors_.p_data()
              , &work, lWork, &iwork, liwork);
  // check any error
  if (info!=0)
  {
    if (info>0)
    { this->msg_error_ = STKERROR_NO_ARG(SymEigen::run,internal error);
      return false;
    }
    this->msg_error_= STKERROR_1ARG(SymEigen::run,-info,error parameter);
    return false;
  }
#ifdef STK_ALGEBRA_DEBUG
  stk_cout << _T("Size needed:") << (int)work << " " << iwork << " " << "\n";
#endif
  // get results and allocate space
  lWork = (int)work;
  liwork = iwork;
  Real* p_work = new Real[lWork];
  int* p_iwork = new int[liwork];
 
  // Call SYEVR with the optimal block size
  info = syevr( jobz_, RANGE_, UPLO_
              , range_.size(), data_.p_data(), range_.size()
              , VL_, VU_, IL_, IU_
              , absTol, &rank_, eigenValues_.p_data()
              , eigenVectors_.p_data(), range_.size(), this->SupportEigenVectors_.p_data()
              , p_work, lWork, p_iwork, liwork);
  // recover memory
  delete[] p_work;
  delete[] p_iwork;
 
  // finalize
  data_.shift(range_.begin());
  eigenVectors_.shift(range_.begin());
  eigenValues_.shift(range_.begin());
  this->SupportEigenVectors_.shift(range_.begin());
  this->finalizeStep();
  this->hasRun_ = true;
  // return the result of the computation
  if (!info) return true;
  if (info>0)
  { this->msg_error_ = STKERROR_NO_ARG(SymEigen::run,internal error);
    return false;
  }
  this->msg_error_= STKERROR_1ARG(SymEigen::run,-info,error parameter);
  return false;
}

References _T, STK::ICArray< Derived >::p_data(), STK::IRunnerBase::run(), STK::ICArray< Derived >::shift(), stk_cout, STKERROR_1ARG, STKERROR_NO_ARG, and STK::lapack::syevr().

setIlAndIu()

template<class SquareArray >

void STK::lapack::SymEigen< SquareArray >::setIlAndIu ( int  il, int  iu  )

inline

Parameters

il,iu

If RANGE_='I', the indices (in ascending order) of the smallest and largest eigenvalues to be returned. 1 <= IL_ <= IU_ <= NL, if NL > 0; IL_ = 1 and IU_ = 0 if NL = 0. Not referenced if RANGE_ = 'A' or 'V'.

Definition at line 160 of file STK_lapack_SymEigen.h.

{ IL_ = il; IU_ = iu;}

References STK::lapack::SymEigen< SquareArray >::IL_, and STK::lapack::SymEigen< SquareArray >::IU_.

setJobz()

template<class SquareArray >

void STK::lapack::SymEigen< SquareArray >::setJobz ( char  jobz )

inline

Parameters

jobz	If jobz ='N': Compute eigenvalues only; If jobz = 'V': Compute eigenvalues and eigenvectors.

Definition at line 137 of file STK_lapack_SymEigen.h.

{ jobz_ = jobz;}

References STK::lapack::SymEigen< SquareArray >::jobz_.

setRange()

template<class SquareArray >

void STK::lapack::SymEigen< SquareArray >::setRange ( char  range )

inline

Parameters

range

range of the eigenvalues to be found. If range = 'A': all eigenvalues will be found. If range = 'V': all eigenvalues in the half-open interval (VL_,VU_] will be found. If range = 'I': the IL_-th through IU_-th eigenvalues will be found.

Definition at line 143 of file STK_lapack_SymEigen.h.

{ RANGE_ = range;}

References STK::ISymEigen< SymEigen< SquareArray > >::range(), and STK::lapack::SymEigen< SquareArray >::RANGE_.

setUplo()

template<class SquareArray >

void STK::lapack::SymEigen< SquareArray >::setUplo ( char  uplo )

inline

Parameters

uplo	values to used in A. If uplo = 'U': Upper triangle of A is stored; If uplo = 'L': Lower triangle of A is stored.

Definition at line 148 of file STK_lapack_SymEigen.h.

{ UPLO_ = uplo;}

References STK::lapack::SymEigen< SquareArray >::UPLO_.

Referenced by STK::hidden::InvertLowerSymMatrixImpl< Matrix, Size_ >::invertLowerSymMatrixXX().

setVlAndVu()

template<class SquareArray >

void STK::lapack::SymEigen< SquareArray >::setVlAndVu ( Real const &  vl, Real const &  vu  )

inline

Parameters

[in]

vl,vu

lower and upper bounds of the interval to be searched for eigenvalues. Not referenced if RANGE_ = 'A' or 'I'.

Definition at line 153 of file STK_lapack_SymEigen.h.

{ VL_ = vl; VU_ = vu;}

References STK::lapack::SymEigen< SquareArray >::VL_, and STK::lapack::SymEigen< SquareArray >::VU_.

Member Data Documentation

IL_

template<class SquareArray >

int STK::lapack::SymEigen< SquareArray >::IL_

private

Definition at line 174 of file STK_lapack_SymEigen.h.

Referenced by STK::lapack::SymEigen< SquareArray >::setIlAndIu().

IU_

template<class SquareArray >

int STK::lapack::SymEigen< SquareArray >::IU_

private

Definition at line 174 of file STK_lapack_SymEigen.h.

Referenced by STK::lapack::SymEigen< SquareArray >::setIlAndIu().

jobz_

template<class SquareArray >

char STK::lapack::SymEigen< SquareArray >::jobz_

private

Lapack pptions.

Definition at line 172 of file STK_lapack_SymEigen.h.

Referenced by STK::lapack::SymEigen< SquareArray >::setJobz().

RANGE_

template<class SquareArray >

char STK::lapack::SymEigen< SquareArray >::RANGE_

private

Definition at line 172 of file STK_lapack_SymEigen.h.

Referenced by STK::lapack::SymEigen< SquareArray >::setRange().

UPLO_

template<class SquareArray >

char STK::lapack::SymEigen< SquareArray >::UPLO_

private

Definition at line 172 of file STK_lapack_SymEigen.h.

Referenced by STK::lapack::SymEigen< SquareArray >::setUplo().

VL_

template<class SquareArray >

Real STK::lapack::SymEigen< SquareArray >::VL_

private

Definition at line 173 of file STK_lapack_SymEigen.h.

Referenced by STK::lapack::SymEigen< SquareArray >::setVlAndVu().

VU_

template<class SquareArray >

Real STK::lapack::SymEigen< SquareArray >::VU_

private

Definition at line 173 of file STK_lapack_SymEigen.h.

Referenced by STK::lapack::SymEigen< SquareArray >::setVlAndVu().

---

The documentation for this class was generated from the following file:

• STK_lapack_SymEigen.h