java.lang.Object
- org.ojalgo.matrix.decomposition.AbstractDecomposition<N,DecompositionStore<N>>
- - org.ojalgo.matrix.decomposition.DenseEigenvalue<N>
  - - org.ojalgo.matrix.decomposition.HermitianEvD<N>

All Implemented Interfaces:

Eigenvalue<N>, Eigenvalue.Spectral<N>, MatrixDecomposition<N>, MatrixDecomposition.Determinant<N>, MatrixDecomposition.EconomySize<N>, MatrixDecomposition.Hermitian<N>, MatrixDecomposition.Ordered<N>, MatrixDecomposition.RankRevealing<N>, MatrixDecomposition.Solver<N>, MatrixDecomposition.Values<N>, SingularValue<N>, Provider2D, Provider2D.Condition, Provider2D.Determinant<N>, Provider2D.Eigenpairs, Provider2D.Inverse<java.util.Optional<MatrixStore<N>>>, Provider2D.Rank, Provider2D.Solution<java.util.Optional<MatrixStore<N>>>, DeterminantTask<N>, InverterTask<N>, MatrixTask<N>, SolverTask<N>, InvertibleFactor<N>, Structure1D, Structure2D

Direct Known Subclasses:

HermitianEvD.C128, HermitianEvD.H256, HermitianEvD.Q128, HermitianEvD.R064, HermitianEvD.R128
```
abstract class HermitianEvD<N extends java.lang.Comparable<N>>
extends DenseEigenvalue<N>
implements Eigenvalue.Spectral<N>
```
Eigenvalues and eigenvectors of a real matrix.
If A is symmetric, then A = V*D*V' where the eigenvalue matrix D is diagonal and the eigenvector matrix V is orthogonal. I.e. A = V.times(D.times(V.transpose())) and V.times(V.transpose()) equals the identity matrix.
If A is not symmetric, then the eigenvalue matrix D is block diagonal with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues, lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda]. The columns of V represent the eigenvectors in the sense that A*V = V*D, i.e. A.times(V) equals V.times(D). The matrix V may be badly conditioned, or even singular, so the validity of the equation A = V*D*inverse(V) depends upon V.cond().

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`(package private) static class`	`HermitianEvD.C128`
`(package private) static class`	`HermitianEvD.H256`
`(package private) static class`	`HermitianEvD.Q128`
`(package private) static class`	`HermitianEvD.R064`
`(package private) static class`	`HermitianEvD.R128`

Nested classes/interfaces inherited from interface org.ojalgo.matrix.decomposition.Eigenvalue
Eigenvalue.Eigenpair, Eigenvalue.Factory<N extends java.lang.Comparable<N>>, Eigenvalue.Generalisation, Eigenvalue.Generalised<N extends java.lang.Comparable<N>>, Eigenvalue.Spectral<N extends java.lang.Comparable<N>>

Nested classes/interfaces inherited from interface org.ojalgo.matrix.transformation.InvertibleFactor
InvertibleFactor.IdentityFactor<N extends java.lang.Comparable<N>>

Nested classes/interfaces inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition
MatrixDecomposition.Determinant<N extends java.lang.Comparable<N>>, MatrixDecomposition.EconomySize<N extends java.lang.Comparable<N>>, MatrixDecomposition.Factory<D extends MatrixDecomposition<?>>, MatrixDecomposition.Hermitian<N extends java.lang.Comparable<N>>, MatrixDecomposition.Ordered<N extends java.lang.Comparable<N>>, MatrixDecomposition.Pivoting<N extends java.lang.Comparable<N>>, MatrixDecomposition.RankRevealing<N extends java.lang.Comparable<N>>, MatrixDecomposition.Solver<N extends java.lang.Comparable<N>>, MatrixDecomposition.Updatable<N extends java.lang.Comparable<N>>, MatrixDecomposition.Values<N extends java.lang.Comparable<N>>

Nested classes/interfaces inherited from interface org.ojalgo.matrix.Provider2D
Provider2D.Condition, Provider2D.Determinant<N extends java.lang.Comparable<N>>, Provider2D.Eigenpairs, Provider2D.Hermitian, Provider2D.Inverse<M>, Provider2D.Rank, Provider2D.Solution<M>, Provider2D.Symmetric, Provider2D.Trace<N extends java.lang.Comparable<N>>

Nested classes/interfaces inherited from interface org.ojalgo.matrix.decomposition.SingularValue
SingularValue.Factory<N extends java.lang.Comparable<N>>

Nested classes/interfaces inherited from interface org.ojalgo.structure.Structure1D
Structure1D.BasicMapper<T>, Structure1D.IndexMapper<T>, Structure1D.IntIndex, Structure1D.LongIndex, Structure1D.LoopCallback

Nested classes/interfaces inherited from interface org.ojalgo.structure.Structure2D
Structure2D.IntRowColumn, Structure2D.Logical<S extends Structure2D,B extends Structure2D.Logical<S,B>>, Structure2D.LongRowColumn, Structure2D.ReducibleTo1D<R extends Structure1D>, Structure2D.Reshapable, Structure2D.RowColumnKey<R,C>, Structure2D.RowColumnMapper<R,C>

Field Summary

Fields
Modifier and Type	Field	Description
`private double[]`	`d`
`private double[]`	`e`
`private MatrixStore<N>`	`myInverse`
`private MatrixStore<N>`	`myS`
`private Array1D<java.lang.Double>`	`mySingularValues`
`private DenseTridiagonal<N>`	`myTridiagonal`
`private MatrixStore<N>`	`myU`

Fields inherited from interface org.ojalgo.matrix.decomposition.Eigenvalue
C128, DESCENDING_NORM, H256, Q128, R064, R128

Fields inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition
TYPICAL

Fields inherited from interface org.ojalgo.matrix.decomposition.SingularValue
C128, H256, Q128, R064, R128

Constructor Summary

Constructors
Modifier	Constructor	Description
`private`	`HermitianEvD(PhysicalStore.Factory<N,? extends DecompositionStore<N>> factory)`
`protected`	`HermitianEvD(PhysicalStore.Factory<N,? extends DecompositionStore<N>> factory, DenseTridiagonal<N> tridiagonal)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`btran(double[] arg)`
`void`	`btran(PhysicalStore<N> arg)`	Backwards-transformation
`boolean`	`checkAndDecompose(MatrixStore<N> matrix)`	Absolutely must check if the matrix is hermitian or not.
`protected boolean`	`checkSolvability()`
`int`	`countSignificant(double threshold)`
`protected boolean`	`doDecompose(Access2D.Collectable<N,? super TransformableRegion<N>> matrix, boolean valuesOnly)`
`void`	`ftran(double[] arg)`
`void`	`ftran(PhysicalStore<N> arg)`	Forward-transformation
`double`	`getCondition()`	The condition number.
`MatrixStore<N>`	`getCovariance()`
`N`	`getDeterminant()`	A matrix' determinant is the product of its eigenvalues.
`void`	`getEigenvalues(double[] realParts, java.util.Optional<double[]> imaginaryParts)`
`double`	`getFrobeniusNorm()`	Sometimes also called the Schatten 2-norm or Hilbert-Schmidt norm.
`MatrixStore<N>`	`getInverse()`	The output must be a "right inverse" and a "generalised inverse".
`MatrixStore<N>`	`getInverse(PhysicalStore<N> preallocated)`	Implementing this method is optional.
`double`	`getKyFanNorm(int k)`	Ky Fan k-norm.
`double`	`getOperatorNorm()`
`double`	`getRankThreshold()`
`MatrixStore<N>`	`getS()`	If there are no negative eigenvalues this method will simply reuse the eigenvalue diagonal (D)
`Array1D<java.lang.Double>`	`getSingularValues()`
`MatrixStore<N>`	`getSolution(Access2D.Collectable<N,? super PhysicalStore<N>> rhs, PhysicalStore<N> preallocated)`	Implementing this method is optional.
`ComplexNumber`	`getTrace()`	A matrix' trace is the sum of the diagonal elements.
`double`	`getTraceNorm()`
`MatrixStore<N>`	`getU()`	For SPD matrices U == V; for indefinite we must absorb eigenvalue sign into U
`MatrixStore<N>`	`invert(Access2D<?> original)`	The output must be a "right inverse" and a "generalised inverse".
`MatrixStore<N>`	`invert(Access2D<?> original, PhysicalStore<N> preallocated)`	Exactly how (if at all) a specific implementation makes use of `preallocated` is not specified by this interface.
`boolean`	`isFullSize()`
`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.
`boolean`	`isSolvable()`	Please note that producing a pseudoinverse and/or a least squares solution is ok! The return value, of this method, is not an indication of if the decomposed matrix is square, has full rank, is postive definite or whatever.
`boolean`	`isSPD()`	A symmetric (Hermitian) matrix is positive definite if all its eigenvalues are positive.
`protected MatrixStore<N>`	`makeD()`
`protected Array1D<ComplexNumber>`	`makeEigenvalues()`
`protected MatrixStore<N>`	`makeV()`
`PhysicalStore<N>`	`preallocate(int nbEquations, int nbVariables, int nbSolutions)`
`MatrixStore<N>`	`reconstruct()`
`void`	`reset()`	Delete computed results, and resets attributes to default values
`MatrixStore<N>`	`solve(Access2D<?> body, Access2D<?> rhs, PhysicalStore<N> preallocated)`	Exactly how (if at all) a specific implementation makes use of `preallocated` is not specified by this interface.
`(package private) static void`	`tql2(double[] d, double[] e, RotateRight mtrxV)`

Methods inherited from class org.ojalgo.matrix.decomposition.DenseEigenvalue
calculateDeterminant, computeValuesOnly, decompose, getColDim, getD, getEigenvalues, getMaxDim, getMinDim, getRowDim, getV, isValuesOnly, setD, setEigenvalues, setV

Methods inherited from class org.ojalgo.matrix.decomposition.AbstractDecomposition
aggregator, applyPivotOrder, applyReverseOrder, collect, computed, copyColumn, copyRow, function, getDimensionalEpsilon, isAspectRatioNormal, isComputed, makeArray, makeDiagonal, makeEye, makeHouseholder, makeIdentity, makeRotation, makeRotation, makeZero, makeZero, scalar, wrap

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.ojalgo.matrix.task.DeterminantTask
calculateDeterminant

Methods inherited from interface org.ojalgo.matrix.decomposition.Eigenvalue
getD, getEigenpair, getEigenpairs, getEigenvalues, getEigenvectors, getV

Methods inherited from interface org.ojalgo.matrix.task.InverterTask
preallocate

Methods inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition
decompose, isComputed

Methods inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition.Determinant
toDeterminantProvider

Methods inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition.RankRevealing
getRank, isFullRank

Methods inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition.Solver
compute, getSolution, invert, preallocate, solve, toInverseProvider, toSolutionProvider

Methods inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition.Values
computeValuesOnly

Methods inherited from interface org.ojalgo.matrix.decomposition.SingularValue
getD, getSingularValues, getV, reconstruct

Methods inherited from interface org.ojalgo.matrix.task.SolverTask
preallocate, solve

Methods inherited from interface org.ojalgo.structure.Structure2D
count, countColumns, countRows, firstInColumn, firstInRow, getColDim, getMaxDim, getMinDim, getRowDim, isEmpty, isFat, isScalar, isSquare, isTall, isVector, limitOfColumn, limitOfRow, size

- Field Detail
  - d
```
private double[] d
```
  - e
```
private double[] e
```
  - myInverse
```
private transient MatrixStore<N extends java.lang.Comparable<N>> myInverse
```
  - myS
```
private transient MatrixStore<N extends java.lang.Comparable<N>> myS
```
  - mySingularValues
```
private transient Array1D<java.lang.Double> mySingularValues
```
  - myTridiagonal
```
private final DenseTridiagonal<N extends java.lang.Comparable<N>> myTridiagonal
```
  - myU
```
private transient MatrixStore<N extends java.lang.Comparable<N>> myU
```
- Constructor Detail
  - HermitianEvD
```
private HermitianEvD(PhysicalStore.Factory<N,? extends DecompositionStore<N>> factory)
```
  - HermitianEvD
```
protected HermitianEvD(PhysicalStore.Factory<N,? extends DecompositionStore<N>> factory,
                       DenseTridiagonal<N> tridiagonal)
```
- Method Detail
  - tql2
```
static void tql2(double[] d,
                 double[] e,
                 RotateRight mtrxV)
```
  - btran
```
public void btran(double[] arg)
```
    Specified by:
    
    btran in interface InvertibleFactor<N extends java.lang.Comparable<N>>
    
    See Also:
    
    InvertibleFactor.IdentityFactor.btran(PhysicalStore)
  - btran
```
public final void btran(PhysicalStore<N> arg)
```
    Description copied from interface: InvertibleFactor
    
    Backwards-transformation
    Solve [x]^T[A] = [b]^T (equivalent to [A]^T[x] = [b]) by transforming [b] into [x] in-place.
    
    Specified by:
    
    btran in interface InvertibleFactor<N extends java.lang.Comparable<N>>
    
    Parameters:
    
    arg - [b] transformed into [x]
  - checkAndDecompose
```
public boolean checkAndDecompose(MatrixStore<N> matrix)
```
    Description copied from interface: MatrixDecomposition.Hermitian
    
    Absolutely must check if the matrix is hermitian or not. Then, depending on the result different paths can be chosen - compute or not / choose different algorithms...
    
    Specified by:
    
    checkAndDecompose in interface MatrixDecomposition.Hermitian<N extends java.lang.Comparable<N>>
    
    Parameters:
    
    matrix - A matrix to check and then (maybe) decompose
    
    Returns:
    
    true if the hermitian check passed and decomposition succeeded; false if not
  - countSignificant
```
public int countSignificant(double threshold)
```
    Specified by:
    
    countSignificant in interface MatrixDecomposition.RankRevealing<N extends java.lang.Comparable<N>>
    
    Parameters:
    
    threshold - Significance limit
    
    Returns:
    
    The number of elements in the diagonal matrix that are greater than the threshold
  - ftran
```
public void ftran(double[] arg)
```
    Specified by:
    
    ftran in interface InvertibleFactor<N extends java.lang.Comparable<N>>
    
    See Also:
    
    InvertibleFactor.IdentityFactor.ftran(PhysicalStore)
  - ftran
```
public void ftran(PhysicalStore<N> arg)
```
    Description copied from interface: InvertibleFactor
    
    Forward-transformation
    Solve [A][x] = [b] by transforming [b] into [x] in-place.
    
    Specified by:
    
    ftran in interface InvertibleFactor<N extends java.lang.Comparable<N>>
    
    Specified by:
    
    ftran in interface SingularValue<N extends java.lang.Comparable<N>>
    
    Parameters:
    
    arg - [b] transformed into [x]
  - getCondition
```
public double getCondition()
```
    Description copied from interface: SingularValue
    
    The condition number.
    
    Specified by:
    
    getCondition in interface Provider2D.Condition
    
    Specified by:
    
    getCondition in interface SingularValue<N extends java.lang.Comparable<N>>
    
    Returns:
    
    The largest singular value divided by the smallest singular value.
  - getCovariance
```
public MatrixStore<N> getCovariance()
```
    Specified by:
    
    getCovariance in interface SingularValue<N extends java.lang.Comparable<N>>
    
    Returns:
    
    [[A]^T[A]]^-1 Where [A] is the original matrix.
  - getDeterminant
```
public N getDeterminant()
```
    Description copied from interface: MatrixDecomposition.Determinant
    
    A matrix' determinant is the product of its eigenvalues.
    
    Specified by:
    
    getDeterminant in interface MatrixDecomposition.Determinant<N extends java.lang.Comparable<N>>
    
    Specified by:
    
    getDeterminant in interface Provider2D.Determinant<N extends java.lang.Comparable<N>>
    
    Returns:
    
    The matrix' determinant
  - getEigenvalues
```
public void getEigenvalues(double[] realParts,
                           java.util.Optional<double[]> imaginaryParts)
```
    Specified by:
    
    getEigenvalues in interface Eigenvalue<N extends java.lang.Comparable<N>>
    
    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
  - getFrobeniusNorm
```
public double getFrobeniusNorm()
```
    Description copied from interface: SingularValue
    
    Sometimes also called the Schatten 2-norm or Hilbert-Schmidt norm.
    
    Specified by:
    
    getFrobeniusNorm in interface SingularValue<N extends java.lang.Comparable<N>>
    
    Returns:
    
    The square root of the sum of squares of the singular values.
  - getInverse
```
public MatrixStore<N> getInverse()
```
    Description copied from interface: MatrixDecomposition.Solver
    
    The output must be a "right inverse" and a "generalised inverse".
    
    Specified by:
    
    getInverse in interface MatrixDecomposition.Solver<N extends java.lang.Comparable<N>>
  - getInverse
```
public MatrixStore<N> getInverse(PhysicalStore<N> preallocated)
```
    Description copied from interface: MatrixDecomposition.Solver
    
    Implementing this method is optional.
    
    Exactly how a specific implementation makes use of preallocated is not specified by this interface. It must be documented for each implementation.
    
    Should produce the same results as calling MatrixDecomposition.Solver.getInverse().
    
    Specified by:
    
    getInverse in interface MatrixDecomposition.Solver<N extends java.lang.Comparable<N>>
    
    Parameters:
    
    preallocated - Preallocated memory for the results, possibly some intermediate results. You must assume this is modified, but you cannot assume it will contain the full/final/correct solution. Use MatrixDecomposition.Solver.preallocate(int, int) or InverterTask.preallocate(Structure2D) to get a suitable instance.
    
    Returns:
    
    The inverse, this is where you get the solution
  - getKyFanNorm
```
public double getKyFanNorm(int k)
```
    Description copied from interface: SingularValue
    
    Ky Fan k-norm.
    
    The first Ky Fan k-norm is the operator norm (the largest singular value), and the last is called the trace norm (the sum of all singular values).
    
    Specified by:
    
    getKyFanNorm in interface SingularValue<N extends java.lang.Comparable<N>>
    
    Parameters:
    
    k - The number of singular values to add up.
    
    Returns:
    
    The sum of the k largest singular values.
  - getOperatorNorm
```
public double getOperatorNorm()
```
    Specified by:
    
    getOperatorNorm in interface SingularValue<N extends java.lang.Comparable<N>>
    
    Returns:
    
    2-norm
  - getRankThreshold
```
public double getRankThreshold()
```
    Specified by:
    
    getRankThreshold in interface MatrixDecomposition.RankRevealing<N extends java.lang.Comparable<N>>
  - getS
```
public MatrixStore<N> getS()
```
    If there are no negative eigenvalues this method will simply reuse the eigenvalue diagonal (D)
    
    Specified by:
    
    getS in interface SingularValue<N extends java.lang.Comparable<N>>
    
    Returns:
    
    The diagonal matrix of singular values.
  - getSingularValues
```
public Array1D<java.lang.Double> getSingularValues()
```
    Specified by:
    
    getSingularValues in interface SingularValue<N extends java.lang.Comparable<N>>
    
    Returns:
    
    The singular values ordered in descending order.
  - getSolution
```
public MatrixStore<N> getSolution(Access2D.Collectable<N,? super PhysicalStore<N>> rhs,
                                  PhysicalStore<N> preallocated)
```
    Description copied from interface: MatrixDecomposition.Solver
    
    Implementing this method is optional.
    
    Exactly how a specific implementation makes use of preallocated is not specified by this interface. It must be documented for each implementation.
    
    Should produce the same results as calling MatrixDecomposition.Solver.getSolution(Collectable).
    
    Specified by:
    
    getSolution in interface MatrixDecomposition.Solver<N extends java.lang.Comparable<N>>
    
    Parameters:
    
    rhs - The Right Hand Side, wont be modfied
    
    preallocated - Preallocated memory for the results, possibly some intermediate results. You must assume this is modified, but you cannot assume it will contain the full/final/correct solution. Use SolverTask.preallocate(int, int, int) or SolverTask.preallocate(Structure2D, Structure2D) to get a suitable instance.
    
    Returns:
    
    The solution
  - getTrace
```
public ComplexNumber getTrace()
```
    Description copied from interface: Eigenvalue
    
    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.
    
    Specified by:
    
    getTrace in interface Eigenvalue<N extends java.lang.Comparable<N>>
    
    Returns:
    
    The matrix' trace
  - getTraceNorm
```
public double getTraceNorm()
```
    Specified by:
    
    getTraceNorm in interface SingularValue<N extends java.lang.Comparable<N>>
  - getU
```
public MatrixStore<N> getU()
```
    For SPD matrices U == V; for indefinite we must absorb eigenvalue sign into U
    
    Specified by:
    
    getU in interface SingularValue<N extends java.lang.Comparable<N>>
  - invert
```
public MatrixStore<N> invert(Access2D<?> original)
                      throws RecoverableCondition
```
    Description copied from interface: InverterTask
    
    The output must be a "right inverse" and a "generalised inverse".
    
    Specified by:
    
    invert in interface InverterTask<N extends java.lang.Comparable<N>>
    
    Throws:
    
    RecoverableCondition
  - invert
```
public MatrixStore<N> invert(Access2D<?> original,
                             PhysicalStore<N> preallocated)
                      throws RecoverableCondition
```
    Description copied from interface: InverterTask
    
    Exactly how (if at all) a specific implementation makes use of preallocated is not specified by this interface. It must be documented for each implementation.
    
    Should produce the same results as calling InverterTask.invert(Access2D).
    
    Use InverterTask.preallocate(Structure2D) to obtain a suitbale preallocated.
    
    Specified by:
    
    invert in interface InverterTask<N extends java.lang.Comparable<N>>
    
    preallocated - Preallocated memory for the results, possibly some intermediate results. You must assume this is modified, but you cannot assume it will contain the full/final/correct solution.
    
    Returns:
    
    The inverse
    
    Throws:
    
    RecoverableCondition - TODO
  - isFullSize
```
public boolean isFullSize()
```
    Specified by:
    
    isFullSize in interface MatrixDecomposition.EconomySize<N extends java.lang.Comparable<N>>
    
    Returns:
    
    True if it will generate a full sized decomposition.
  - isHermitian
```
public boolean isHermitian()
```
    Description copied from interface: Eigenvalue
    
    If [A] is hermitian then [V][D][V]^-1 becomes [Q][D][Q]^H...
    
    Specified by:
    
    isHermitian in interface Eigenvalue<N extends java.lang.Comparable<N>>
  - isOrdered
```
public boolean isOrdered()
```
    Description copied from interface: Eigenvalue
    
    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 Eigenvalue<N extends java.lang.Comparable<N>>
    
    Specified by:
    
    isOrdered in interface MatrixDecomposition.Ordered<N extends java.lang.Comparable<N>>
    
    Returns:
    
    true if they are ordered
  - isSolvable
```
public boolean isSolvable()
```
    Description copied from interface: MatrixDecomposition.Solver
    
    Please note that producing a pseudoinverse and/or a least squares solution is ok! The return value, of this method, is not an indication of if the decomposed matrix is square, has full rank, is postive definite or whatever. It's that in combination with the specific decomposition algorithm's capabilities.
    
    Specified by:
    
    isSolvable in interface MatrixDecomposition.Solver<N extends java.lang.Comparable<N>>
    
    Overrides:
    
    isSolvable in class AbstractDecomposition<N extends java.lang.Comparable<N>,DecompositionStore<N extends java.lang.Comparable<N>>>
    
    Returns:
    
    true if this matrix decomposition is in a state to be able to deliver an inverse or an equation system solution (with some degree of numerical stability).
  - isSPD
```
public boolean isSPD()
```
    Description copied from interface: Eigenvalue.Spectral
    
    A symmetric (Hermitian) matrix is positive definite if all its eigenvalues are positive.
    
    Specified by:
    
    isSPD in interface Eigenvalue.Spectral<N extends java.lang.Comparable<N>>
  - preallocate
```
public PhysicalStore<N> preallocate(int nbEquations,
                                    int nbVariables,
                                    int nbSolutions)
```
    Specified by:
    
    preallocate in interface SolverTask<N extends java.lang.Comparable<N>>
  - reconstruct
```
public MatrixStore<N> reconstruct()
```
    Specified by:
    
    reconstruct in interface Eigenvalue<N extends java.lang.Comparable<N>>
    
    Specified by:
    
    reconstruct in interface Eigenvalue.Spectral<N extends java.lang.Comparable<N>>
    
    Specified by:
    
    reconstruct in interface MatrixDecomposition<N extends java.lang.Comparable<N>>
    
    Specified by:
    
    reconstruct in interface SingularValue<N extends java.lang.Comparable<N>>
  - reset
```
public void reset()
```
    Description copied from interface: MatrixDecomposition
    
    Delete computed results, and resets attributes to default values
    
    Specified by:
    
    reset in interface MatrixDecomposition<N extends java.lang.Comparable<N>>
    
    Overrides:
    
    reset in class DenseEigenvalue<N extends java.lang.Comparable<N>>
  - solve
```
public MatrixStore<N> solve(Access2D<?> body,
                            Access2D<?> rhs,
                            PhysicalStore<N> preallocated)
                     throws RecoverableCondition
```
    Description copied from interface: SolverTask
    
    Exactly how (if at all) a specific implementation makes use of preallocated is not specified by this interface. It must be documented for each implementation.
    
    Should produce the same results as calling SolverTask.solve(Access2D, Access2D).
    
    Use SolverTask.preallocate(Structure2D, Structure2D) to obtain a suitbale preallocated.
    
    Specified by:
    
    solve in interface SolverTask<N extends java.lang.Comparable<N>>
    
    rhs - The Right Hand Side, wont be modfied
    
    preallocated - Preallocated memory for the results, possibly some intermediate results. You must assume this is modified, but you cannot assume it will contain the full/ /correct solution.
    
    Returns:
    
    The solution
    
    Throws:
    
    RecoverableCondition
  - checkSolvability
```
protected boolean checkSolvability()
```
    Overrides:
    
    checkSolvability in class AbstractDecomposition<N extends java.lang.Comparable<N>,DecompositionStore<N extends java.lang.Comparable<N>>>
  - doDecompose
```
protected boolean doDecompose(Access2D.Collectable<N,? super TransformableRegion<N>> matrix,
                              boolean valuesOnly)
```
    Specified by:
    
    doDecompose in class DenseEigenvalue<N extends java.lang.Comparable<N>>
  - makeD
```
protected MatrixStore<N> makeD()
```
    Specified by:
    
    makeD in class DenseEigenvalue<N extends java.lang.Comparable<N>>
  - makeEigenvalues
```
protected Array1D<ComplexNumber> makeEigenvalues()
```
    Specified by:
    
    makeEigenvalues in class DenseEigenvalue<N extends java.lang.Comparable<N>>
  - makeV
```
protected MatrixStore<N> makeV()
```
    Specified by:
    
    makeV in class DenseEigenvalue<N extends java.lang.Comparable<N>>

Class HermitianEvD<N extends java.lang.Comparable<N>>

Nested Class Summary

Nested classes/interfaces inherited from interface org.ojalgo.matrix.decomposition.Eigenvalue

Nested classes/interfaces inherited from interface org.ojalgo.matrix.transformation.InvertibleFactor

Nested classes/interfaces inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition

Nested classes/interfaces inherited from interface org.ojalgo.matrix.Provider2D

Nested classes/interfaces inherited from interface org.ojalgo.matrix.decomposition.SingularValue

Nested classes/interfaces inherited from interface org.ojalgo.structure.Structure1D

Nested classes/interfaces inherited from interface org.ojalgo.structure.Structure2D

Field Summary

Fields inherited from interface org.ojalgo.matrix.decomposition.Eigenvalue

Fields inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition

Fields inherited from interface org.ojalgo.matrix.decomposition.SingularValue

Constructor Summary

Method Summary

Methods inherited from class org.ojalgo.matrix.decomposition.DenseEigenvalue

Methods inherited from class org.ojalgo.matrix.decomposition.AbstractDecomposition

Methods inherited from class java.lang.Object

Methods inherited from interface org.ojalgo.matrix.task.DeterminantTask

Methods inherited from interface org.ojalgo.matrix.decomposition.Eigenvalue

Methods inherited from interface org.ojalgo.matrix.task.InverterTask

Methods inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition

Methods inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition.Determinant

Methods inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition.RankRevealing

Methods inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition.Solver

Methods inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition.Values

Methods inherited from interface org.ojalgo.matrix.decomposition.SingularValue

Methods inherited from interface org.ojalgo.matrix.task.SolverTask

Methods inherited from interface org.ojalgo.structure.Structure2D

Field Detail

d

e

myInverse

myS

mySingularValues

myTridiagonal

myU

Constructor Detail

HermitianEvD

HermitianEvD

Method Detail

tql2

btran

btran

checkAndDecompose

countSignificant

ftran

ftran

getCondition

getCovariance

getDeterminant

getEigenvalues

getFrobeniusNorm

getInverse

getInverse

getKyFanNorm

getOperatorNorm

getRankThreshold

getS

getSingularValues

getSolution

getTrace

getTraceNorm

getU

invert

invert

isFullSize

isHermitian

isOrdered

isSolvable

isSPD

preallocate

reconstruct

reset

solve

checkSolvability

doDecompose

makeD

makeEigenvalues

makeV