CppNoddy::DenseLinearEigenSystem< _Type > Class Template Reference

A linear Nth-order generalised eigensystem class. More...

#include <DenseLinearEigenSystem.h>

Inheritance diagram for CppNoddy::DenseLinearEigenSystem< _Type >:

Public Member Functions
	DenseLinearEigenSystem (DenseMatrix< _Type > *Aptr, DenseMatrix< _Type > *Bptr)
	Constructor for a linear system object. More...
	~DenseLinearEigenSystem ()
	Destructor for a linear system object. More...
void	eigensolve ()
	Solve the matrix linear eigensystem. More...
void	tag_eigenvalues_right (const int &val)
	Tag those eigenvalues that are to the right of a specified point. More...
void	tag_eigenvalues_left (const int &val)
	Tag those eigenvalues that are to the left of a specified point. More...
void	tag_eigenvalues_upper (const int &val)
	Tag those eigenvalues that are in the upper half-plane above a specified point. More...
void	tag_eigenvalues_lower (const int &val)
	Tag those eigenvalues that are in the lower half-plane below a specified point. More...
void	tag_eigenvalues_disc (const int &val, const double &radius)
	Tag those eigenvalues that are within a disc centred at a point in the complex plane. More...
DenseVector< D_complex >	get_tagged_eigenvalues () const
	Get the the tagged eigenvalues. More...
DenseMatrix< D_complex >	get_tagged_eigenvectors () const
	Get the the tagged eigenvectors. More...
Public Member Functions inherited from CppNoddy::LinearEigenSystem_base
	LinearEigenSystem_base ()
	Constructor for a linear system object. More...
virtual	~LinearEigenSystem_base ()
	Destructor for a linear system object. More...
virtual void	eigensolve ()
	Solve the matrix linear eigensystem. More...
void	set_calc_eigenvectors (bool flag)
	Compute the eigenvectors in any eigenvalue computation. More...
void	set_shift (const D_complex &z)
	Set the shift value to be used in tagging. More...
D_complex	get_shift () const
	Get the shift value associated with this class (used for tagging) and eigenvalue tagging. More...
virtual void	tag_eigenvalues_right (const int &val)
	Tag those eigenvalues that are to the right of a specified shft point. More...
virtual void	tag_eigenvalues_left (const int &val)
	Tag those eigenvalues that are to the left of a specified point. More...
virtual void	tag_eigenvalues_upper (const int &val)
	Tag those eigenvalues that are in the upper half-plane above a specified point. More...
virtual void	tag_eigenvalues_lower (const int &val)
	Tag those eigenvalues that are in the lower half-plane below a specified point. More...
virtual void	tag_eigenvalues_disc (const int &val, const double &radius)
	Tag those eigenvalues that are within a disc centred at a point in the complex plane. More...
virtual void	tag_eigenvalues_all ()
	Tag all the eigenvalues returned from the ARPACK routine. More...
virtual void	clear_all_tags ()
virtual DenseVector< D_complex >	get_tagged_eigenvalues () const
	Get the the tagged eigenvalues. More...
virtual DenseMatrix< D_complex >	get_tagged_eigenvectors () const
	Get the the tagged eigenvectors. More...

Additional Inherited Members
Protected Types inherited from CppNoddy::LinearEigenSystem_base
typedef std::set< unsigned, std::less< unsigned > >::iterator	iter
typedef std::set< unsigned, std::less< unsigned > >::const_iterator	citer
Protected Attributes inherited from CppNoddy::LinearEigenSystem_base
DenseVector< D_complex >	m_all_eigenvalues
	storage for eigenvectors and eigenvalues More...
DenseMatrix< D_complex >	m_all_eigenvectors
std::set< unsigned, std::less< unsigned > >	m_tagged_indices
	a set of tagged eigenvalue indices More...
D_complex	m_shift
	The complex shift value. More...
bool	m_calc_eigenvectors
	calculate the eigenvectors in any eigenvalue computation More...

Detailed Description

template<typename _Type>
class CppNoddy::DenseLinearEigenSystem< _Type >

A linear Nth-order generalised eigensystem class.

Here we can construct a linear eigenproblem in the form

for dense double/complex matrices and . The eigenvalues and eigenvectors can be tagged and retrieved as required.

Definition at line 19 of file DenseLinearEigenSystem.h.

Constructor & Destructor Documentation

DenseLinearEigenSystem()

template<typename _Type >

CppNoddy::DenseLinearEigenSystem< _Type >::DenseLinearEigenSystem	(	DenseMatrix< _Type > *	Aptr,
		DenseMatrix< _Type > *	Bptr
	)

Constructor for a linear system object.

Parameters

Aptr	A pointer to a typed A matrix
Bptr	A pointer to a typed B matrix

Definition at line 17 of file DenseLinearEigenSystem.cpp.

                                                                                                          :
    LinearEigenSystem_base() {
    m_pA = Aptr;
    m_pB = Bptr;
  }

~DenseLinearEigenSystem()

template<typename _Type >

CppNoddy::DenseLinearEigenSystem< _Type >::~DenseLinearEigenSystem

Destructor for a linear system object.

Definition at line 24 of file DenseLinearEigenSystem.cpp.

  {}

Member Function Documentation

eigensolve()

template<typename _Type >

void CppNoddy::DenseLinearEigenSystem< _Type >::eigensolve

virtual

Solve the matrix linear eigensystem.

Reimplemented from CppNoddy::LinearEigenSystem_base.

Definition at line 28 of file DenseLinearEigenSystem.cpp.

                                                 {
    // reset any tagged eigenvalues
    m_tagged_indices.clear();
    //
    if(m_calc_eigenvectors) {
      eigensolve_lapack_with_vectors();
    } else {
      eigensolve_lapack_without_vectors();
    }
  }

Referenced by CppNoddy::HST::Orr_Sommerfeld::global_evp(), CppNoddy::HST::Rayleigh< _Type >::global_evp(), and main().

get_tagged_eigenvalues()

template<typename _Type >

DenseVector< D_complex > CppNoddy::DenseLinearEigenSystem< _Type >::get_tagged_eigenvalues

virtual

Get the the tagged eigenvalues.

All of the tagged eigenvalues are returned in a complex vector, with no ordering guaranteed.

Returns

The tagged eigenvalues as a complex vector

Reimplemented from CppNoddy::LinearEigenSystem_base.

Definition at line 337 of file DenseLinearEigenSystem.cpp.

                                                                                     {
    if(m_tagged_indices.size() == 0) {
      std::string problem;
      problem = "In DenseLinearEigenSystem.get_tagged_eigenvalues() : there are\n";
      problem += "no eigenvalues that have been tagged. This set is empty.\n";
      throw ExceptionRuntime(problem);
    }
    // storage for the eigenvalues
    DenseVector<D_complex> evals;
    // loop through the tagged set
    for(iter p = m_tagged_indices.begin(); p != m_tagged_indices.end(); ++p) {
      // get the index of the relevant eigenvalue from the set
      std::size_t j = *p;
      // work out the complex eigenvalue associated with this index
      // and add it to the vector
      evals.push_back(m_eigenvalues_alpha[ j ] / m_eigenvalues_beta[ j ]);
    }
    // return the complex vector of eigenvalues
    return evals;
  }

References p, and CppNoddy::DenseVector< _Type >::push_back().

Referenced by CppNoddy::HST::Orr_Sommerfeld::global_evp(), CppNoddy::HST::Rayleigh< _Type >::global_evp(), and main().

get_tagged_eigenvectors()

template<typename _Type >

DenseMatrix< D_complex > CppNoddy::DenseLinearEigenSystem< _Type >::get_tagged_eigenvectors

virtual

Get the the tagged eigenvectors.

All of the eigenvectors associated with the tagged eigenvalues are returned, with the i-th eigenvector corresponding to the i-th eigenvalue as returned by the get_tagged_eigenvalues method. The i-th eigenvector is returned in row i of the complex dense matrix.

Returns

The tagged eigenvectors as a complex matrix

Reimplemented from CppNoddy::LinearEigenSystem_base.

Definition at line 359 of file DenseLinearEigenSystem.cpp.

                                                                                      {
    if(m_tagged_indices.size() == 0) {
      std::string problem;
      problem = "In DenseLinearEigenSystem.get_tagged_eigenvectors() : there are\n";
      problem += "no eigenvalues that have been tagged. This set is empty.\n";
      throw ExceptionRuntime(problem);
    }
    // order of the problem
    std::size_t N = m_eigenvalues_alpha.size();
    // eigenvector storage : size() eigenvectors each of length N
    DenseMatrix<D_complex> evecs(m_tagged_indices.size(), N, 0.0);
    std::size_t row = 0;
    // loop through the tagged set
    for(iter p = m_tagged_indices.begin(); p != m_tagged_indices.end(); ++p) {
      // get the index of the relevant eigenvalue from the set
      std::size_t j = *p;
      // put the eigenvector in the matrix
      evecs[ row ] = m_all_eigenvectors[ j ];
      // next row/eigenvector
      ++row;
    }
    return evecs;
  }

References p.

Referenced by CppNoddy::HST::Rayleigh< _Type >::global_evp(), and main().

tag_eigenvalues_disc()

template<typename _Type >

void CppNoddy::DenseLinearEigenSystem< _Type >::tag_eigenvalues_disc ( const int &  val, const double &  radius  )

virtual

Tag those eigenvalues that are within a disc centred at a point in the complex plane.

Parameters

val	Tags are added or removed for val +ve or -ve
radius	The radius of the disc to be considered

Reimplemented from CppNoddy::LinearEigenSystem_base.

Definition at line 386 of file DenseLinearEigenSystem.cpp.

                                                                                               {
    // loop through all the eigenvalues
    for(std::size_t i = 0; i < m_eigenvalues_alpha.size(); ++i) {
      // if the eigenvalue is in the disc centred at m_shift then include it
      if(std::abs(m_eigenvalues_alpha[ i ] - m_shift * m_eigenvalues_beta[ i ]) <
          std::abs(radius * m_eigenvalues_beta[ i ])) {
        if(val > 0) {
          // add it to our set of tagged eigenvalues
          m_tagged_indices.insert(m_tagged_indices.end(), i);
        } else {
          // remove it from the set if it exists
          m_tagged_indices.erase(i);
        }
      }
    }
  }

Referenced by CppNoddy::HST::Orr_Sommerfeld::global_evp(), CppNoddy::HST::Rayleigh< _Type >::global_evp(), and main().

tag_eigenvalues_left()

template<typename _Type >

void CppNoddy::DenseLinearEigenSystem< _Type >::tag_eigenvalues_left ( const int &  val )

virtual

Tag those eigenvalues that are to the left of a specified point.

Parameters

val	Tags are added or removed for val +ve or -ve

Reimplemented from CppNoddy::LinearEigenSystem_base.

Definition at line 423 of file DenseLinearEigenSystem.cpp.

                                                                         {
    double real_value = m_shift.real();
    // loop through all the eigenvalues
    for(std::size_t i = 0; i < m_eigenvalues_alpha.size(); ++i) {
      // if the eigenvalue is to the left of the shift position
      if((m_eigenvalues_alpha[ i ] * std::conj(m_eigenvalues_beta[ i ])).real() <
          std::pow(std::abs(m_eigenvalues_beta[ i ]), 2) * real_value) {
        if(val > 0) {
          // add it to our set of tagged eigenvalues
          m_tagged_indices.insert(m_tagged_indices.end(), i);
        } else {
          // remove it from the set if it exists
          m_tagged_indices.erase(i);
        }
      }
    }
  }

tag_eigenvalues_lower()

template<typename _Type >

void CppNoddy::DenseLinearEigenSystem< _Type >::tag_eigenvalues_lower ( const int &  val )

virtual

Tag those eigenvalues that are in the lower half-plane below a specified point.

Parameters

val	Tags are added or removed for val +ve or -ve

Reimplemented from CppNoddy::LinearEigenSystem_base.

Definition at line 461 of file DenseLinearEigenSystem.cpp.

                                                                          {
    double imag_value = m_shift.imag();
    // loop through all the eigenvalues
    for(std::size_t i = 0; i < m_eigenvalues_alpha.size(); ++i) {
      // if the eigenvalue is in the half plane then include it
      if((m_eigenvalues_alpha[ i ] * std::conj(m_eigenvalues_beta[ i ])).imag() <
          std::pow(std::abs(m_eigenvalues_beta[ i ]), 2) * imag_value) {
        if(val > 0) {
          // add it to our set of tagged eigenvalues
          m_tagged_indices.insert(m_tagged_indices.end(), i);
        } else {
          // remove it from the set if it exists
          m_tagged_indices.erase(i);
        }
      }
    }
  }

tag_eigenvalues_right()

template<typename _Type >

void CppNoddy::DenseLinearEigenSystem< _Type >::tag_eigenvalues_right ( const int &  val )

virtual

Tag those eigenvalues that are to the right of a specified point.

Parameters

val	Tags are added or removed for val +ve or -ve

Reimplemented from CppNoddy::LinearEigenSystem_base.

Definition at line 404 of file DenseLinearEigenSystem.cpp.

                                                                          {
    double real_value = m_shift.real();
    // loop through all the eigenvalues
    for(std::size_t i = 0; i < m_eigenvalues_alpha.size(); ++i) {
      // if the eigenvalue is to the right of the shift position
      if((m_eigenvalues_alpha[ i ] * std::conj(m_eigenvalues_beta[ i ])).real() >
          std::pow(std::abs(m_eigenvalues_beta[ i ]), 2) * real_value) {
        if(val > 0) {
          // add it to our set of tagged eigenvalues
          m_tagged_indices.insert(m_tagged_indices.end(), i);
        } else {
          // remove it from the set if it exists
          m_tagged_indices.erase(i);
        }
      }
    }
  }

tag_eigenvalues_upper()

template<typename _Type >

void CppNoddy::DenseLinearEigenSystem< _Type >::tag_eigenvalues_upper ( const int &  val )

virtual

Tag those eigenvalues that are in the upper half-plane above a specified point.

Parameters

val	Tags are added or removed for val +ve or -ve

Reimplemented from CppNoddy::LinearEigenSystem_base.

Definition at line 442 of file DenseLinearEigenSystem.cpp.

                                                                          {
    double imag_value = m_shift.imag();
    // loop through all the eigenvalues
    for(std::size_t i = 0; i < m_eigenvalues_alpha.size(); ++i) {
      // if the eigenvalue is in the half plane then include it
      if((m_eigenvalues_alpha[ i ] * std::conj(m_eigenvalues_beta[ i ])).imag() >
          std::pow(std::abs(m_eigenvalues_beta[ i ]), 2) * imag_value) {
        if(val > 0) {
          // add it to our set of tagged eigenvalues
          m_tagged_indices.insert(m_tagged_indices.end(), i);
        } else {
          // remove it from the set if it exists
          m_tagged_indices.erase(i);
        }
      }
    }
  }

Referenced by main().

---

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

• include/DenseLinearEigenSystem.h
• src/DenseLinearEigenSystem.cpp