syten::DenseEigensolver::DenseEigensolverBase< Type > Struct Template Reference

Dense nonsymmetric eigensolver, nonfunctional templated inheritance base. More...

#include <dense_eigensolver.h>

Inheritance diagram for syten::DenseEigensolver::DenseEigensolverBase< Type >:

Collaboration diagram for syten::DenseEigensolver::DenseEigensolverBase< Type >:

Public Types
typedef Type	Scalar
	The scalar type to be used. More...

Public Attributes
DenseTensor< 1, Scalar >	evalues
	Vector of eigenvalues, unsorted! More...
DenseTensor< 2, Scalar >	left_evectors
	Matrix of left eigenvectors, each row contains one complex-conjugated vector. More...
DenseTensor< 2, Scalar >	right_evectors
	Matrix of right eigenvectors, each row contains one eigenvector. More...

Detailed Description

template<typename Type>
struct syten::DenseEigensolver::DenseEigensolverBase< Type >

Dense nonsymmetric eigensolver, nonfunctional templated inheritance base.

Example usage:

#include "inc/dense/dense.h"
#include "inc/dense/dense_make.h"
#include "inc/dense/dense_eigensolver.h"
#include "inc/dense/dense_transpose.h"
#include "inc/dense/dense_convenience.h"
#include "inc/dense/dense_prod.h"
#include "inc/dense/dense_operators.h"
 
#include "inc/util/bpo_helper.h"
 
namespace syten {
  int main(int argc, char** argv) {
    Index sidelength{3};
    SYTEN_BPO_INIT;
    opt.add_options()
      ("length,l", boost::program_options::value(&sidelength), "sidelength")
      ;
    SYTEN_BPO_EXEC;
 
    auto mat = DenseTensor<2>({sidelength, sidelength});
    makeRandom(mat); // generate the matrix
 
    auto solver = DenseEigensolver::DenseEigensolver<SDef>(transpose(mat), true, true);
 
    // build diagonal matrix
    DenseTensor<2> diag({sidelength, sidelength});
    for(Index i(0); i != sidelength; ++i) {
      diag[{i,i}] = solver.evalues[i];
    }
 
    auto lvecs = conj(solver.left_evectors); // matrix of left eigenvectors, one per row
    auto lm = prodD<1>(lvecs, mat, {-1, 1}, {1, -2});
    auto dl = prodD<1>(diag, lvecs, {-1, 1}, {1, -2});
    std::cerr << norm(lm-dl) << "\n";
 
    auto rvecs = transpose(solver.right_evectors); // matrix of right eigenvectors, one per column
    auto mr = prodD<1>(mat, rvecs, {-1, 1}, {1, -2});
    auto rd = prodD<1>(rvecs, diag, {-1, 1}, {1, -2});
    std::cerr << norm(mr-rd) << "\n";
 
    return 0;
  }
}
 
int main(int argc, char** argv) { return syten::main(argc, argv); }

Note that (in the language above), lvecs·mat·rvecs is typically not diag. To achieve this, you need to scale either the rows of lvecs or the columns of rvecs by the factor diag[i,i]/(lvecs·mat·rvecs)[i,i]. This ambiguity is due to the matrix being nonsymmetric in general and hence there being no easy relation between lvecs and rvecs (or their product being orthogonal which would otherwise allow normalisation).

---

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

• inc/dense/dense_eigensolver.h