org.ojalgo.matrix.decomposition

## Interface Eigenvalue<N extends Number>

• All Superinterfaces:
All Known Implementing Classes:
HermitianEvD

```public interface Eigenvalue<N extends Number>
extends MatrixDecomposition<N>, MatrixDecomposition.Hermitian<N>, MatrixDecomposition.Determinant<N>, MatrixDecomposition.Values<N>```
[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.

Author:
apete
• ### Nested Class Summary

Nested Classes
Modifier and Type Interface and Description
`static class ` `Eigenvalue.Eigenpair`
`static interface ` `Eigenvalue.Factory<N extends Number>`
• ### Nested classes/interfaces inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition

`MatrixDecomposition.Determinant<N extends Number>, MatrixDecomposition.EconomySize<N extends Number>, MatrixDecomposition.Hermitian<N extends Number>, MatrixDecomposition.Solver<N extends Number>, MatrixDecomposition.Values<N extends Number>`
• ### Field Summary

Fields
Modifier and Type Field and Description
`static Eigenvalue.Factory<BigDecimal>` `BIG`
`static Eigenvalue.Factory<ComplexNumber>` `COMPLEX`
`static Eigenvalue.Factory<Double>` `PRIMITIVE`
• ### Fields inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition

`TYPICAL`
• ### Method Summary

All Methods
Modifier and Type Method and Description
`default void` ```copyEigenvector(int index, Array1D<ComplexNumber> destination)```
Deprecated.
With Java 9 this will be made private. Use `getEigenvectors()` or `getEigenvector(int)` instead.
`static <N extends Number>boolean` ```equals(MatrixStore<N> matrix, Eigenvalue<N> decomposition, NumberContext context)```
`MatrixStore<N>` `getD()`
The only requirements on [D] are that it should contain the eigenvalues and that [A][V] = [V][D].
`default Eigenvalue.Eigenpair` `getEigenpair(int index)`
`Array1D<ComplexNumber>` `getEigenvalues()`
Even for real matrices the eigenvalues (and eigenvectors) are potentially complex numbers.
`default void` ```getEigenvalues(double[] realParts, Optional<double[]> imaginaryParts)```
`default MatrixStore<ComplexNumber>` `getEigenvector(int index)`
Deprecated.
`default MatrixStore<ComplexNumber>` `getEigenvectors()`
`ComplexNumber` `getTrace()`
A matrix' trace is the sum of the diagonal elements.
`MatrixStore<N>` `getV()`
The columns of [V] represent the eigenvectors of [A] in the sense that [A][V] = [V][D].
`boolean` `isHermitian()`
If [A] is hermitian then [V][D][V]-1 becomes [Q][D][Q]H...
`boolean` `isOrdered()`
The eigenvalues in D (and the eigenvectors in V) are not necessarily ordered.
`static <N extends Number>Eigenvalue<N>` `make(Access2D<N> typical)`
`static <N extends Number>Eigenvalue<N>` ```make(Access2D<N> typical, boolean hermitian)```
`default MatrixStore<N>` `reconstruct()`
`static <N extends Number>MatrixStore<N>` `reconstruct(Eigenvalue<N> decomposition)`
• ### Methods inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition.Hermitian

`checkAndCompute`
• ### Methods inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition.Determinant

`getDeterminant`

`calculateDeterminant`
• ### Methods inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition.Values

`computeValuesOnly`
• ### Methods inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition

`decompose, isComputed, reset`
• ### Field Detail

• #### BIG

`static final Eigenvalue.Factory<BigDecimal> BIG`
• #### COMPLEX

`static final Eigenvalue.Factory<ComplexNumber> COMPLEX`
• #### PRIMITIVE

`static final Eigenvalue.Factory<Double> PRIMITIVE`
• ### Method Detail

• #### make

`static <N extends Number> Eigenvalue<N> make(Access2D<N> typical)`
• #### make

```static <N extends Number> Eigenvalue<N> make(Access2D<N> typical,
boolean hermitian)```
• #### equals

```static <N extends Number> boolean equals(MatrixStore<N> matrix,
Eigenvalue<N> decomposition,
NumberContext context)```
• #### reconstruct

`static <N extends Number> MatrixStore<N> reconstruct(Eigenvalue<N> decomposition)`
• #### 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)`
• #### 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.

Prior to v41 this array should always be ordered in descending order - largest (modulus) first. As of v41 the values should be in the same order as the matrices "V" and "D", and if that is 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.Values<N extends Number>`
Returns:
true if they are ordered
• #### reconstruct

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