Interface Eigenvalue<N extends Comparable<N>>

All Superinterfaces:
DeterminantTask<N>, MatrixDecomposition<N>, MatrixDecomposition.Determinant<N>, MatrixDecomposition.Hermitian<N>, MatrixDecomposition.Ordered<N>, MatrixDecomposition.Values<N>, MatrixTask<N>, Provider2D, Provider2D.Determinant<N>, Provider2D.Eigenpairs, Structure1D, Structure2D
All Known Subinterfaces:
Eigenvalue.Generalised<N>, Eigenvalue.Spectral<N>
All Known Implementing Classes:
DenseEigenvalue, DynamicEvD, DynamicEvD.R064, GeneralEvD, GeneralEvD.R064, GeneralisedEvD, HermitianEvD, HermitianEvD.C128, HermitianEvD.H256, HermitianEvD.Q128, HermitianEvD.R064, HermitianEvD.R128, RawEigenvalue, RawEigenvalue.Dynamic, RawEigenvalue.General, RawEigenvalue.Symmetric
public interface Eigenvalue<N extends Comparable<N>> extends MatrixDecomposition.Hermitian<N>, MatrixDecomposition.Determinant<N>, MatrixDecomposition.Values<N>, Provider2D.Eigenpairs
[A] = [V][D][V]-1 ([A][V] = [V][D])
  • [A] = any square matrix.
  • [V] = contains the eigenvectors as columns.
  • [D] = a diagonal matrix with the eigenvalues on the diagonal (possibly in blocks).

[A] is normal if [A][A]H = [A]H[A], and [A] is normal if and only if there exists a unitary matrix [Q] such that [A] = [Q][D][Q]H. Hermitian matrices are normal.

[V] and [D] can always be calculated in the sense that they will satisfy [A][V] = [V][D], but it is not always possible to calculate [V]-1. (Check the rank and/or the condition number of [V] to determine the validity of [V][D][V]-1.)

The eigenvalues (and their corresponding eigenvectors) of a non-symmetric matrix could be complex.

  • Field Details

  • Method Details

    • equals

      static <N extends Comparable<N>> boolean equals(MatrixStore<N> matrix, Eigenvalue<N> decomposition, NumberContext context)

    • reconstruct

      static <N extends Comparable<N>> MatrixStore<N> reconstruct(Eigenvalue<N> decomposition)

    • sort

      static void sort(double[] values, ExchangeColumns vectorExchange)
      Sort eigenvalues and corresponding vectors.
      Parameters:
      values - The eigenvalues to sort
      vectorExchange - A function that can exchange the eigenvectors to follow the new order.

    • copyEigenvector

      private void copyEigenvector(int index, Array1D<ComplexNumber> destination)

    • getD

      MatrixStore<N> getD()
      The only requirements on [D] are that it should contain the eigenvalues and that [A][V] = [V][D]. The ordering of the eigenvalues is not specified.
      • If [A] is real and symmetric then [D] is (purely) diagonal with real eigenvalues.
      • If [A] is real but not symmetric then [D] is block-diagonal with real eigenvalues in 1-by-1 blocks and complex eigenvalues in 2-by-2 blocks.
      • If [A] is complex then [D] is (purely) diagonal with complex eigenvalues.
      Returns:
      The (block) diagonal eigenvalue matrix.

    • getEigenpair

      default Eigenvalue.Eigenpair getEigenpair(int index)

    • getEigenpairs

      default List<Eigenvalue.Eigenpair> getEigenpairs()
      This list is always ordered in descending eigenvalue order – that's regardless of if isOrdered() returns true or false.
      Specified by:
      getEigenpairs in interface Provider2D.Eigenpairs
      See Also:

    • getEigenvalues

      Array1D<ComplexNumber> getEigenvalues()

      Even for real matrices the eigenvalues (and eigenvectors) are potentially complex numbers. Typically they need to be expressed as complex numbers when [A] is not symmetric.

      The values should be in the same order as the matrices "V" and "D", and if they are ordered or not is indicated by the isOrdered() method.

      Returns:
      The eigenvalues.

    • getEigenvalues

      default void getEigenvalues(double[] realParts, Optional<double[]> imaginaryParts)
      Parameters:
      realParts - An array that will receive the real parts of the eigenvalues
      imaginaryParts - An optional array that, if present, will receive the imaginary parts of the eigenvalues

    • getEigenvectors

      default MatrixStore<ComplexNumber> getEigenvectors()
      Returns:
      A complex valued alternative to getV().

    • getTrace

      ComplexNumber getTrace()
      A matrix' trace is the sum of the diagonal elements. It is also the sum of the eigenvalues. This method should return the sum of the eigenvalues.
      Returns:
      The matrix' trace

    • getV

      MatrixStore<N> getV()
      The columns of [V] represent the eigenvectors of [A] in the sense that [A][V] = [V][D].
      Returns:
      The eigenvector matrix.

    • isHermitian

      boolean isHermitian()
      If [A] is hermitian then [V][D][V]-1 becomes [Q][D][Q]H...

    • isOrdered

      boolean isOrdered()
      The eigenvalues in D (and the eigenvectors in V) are not necessarily ordered. This is a property of the algorithm/implementation, not the data.
      Specified by:
      isOrdered in interface MatrixDecomposition.Ordered<N extends Comparable<N>>
      Returns:
      true if they are ordered

    • reconstruct

      default MatrixStore<N> reconstruct()
      Specified by:
      reconstruct in interface MatrixDecomposition<N extends Comparable<N>>