DecompositionOperations<TReal, TComplex> Class

Specifies the methods that must be implemented by a class to support complex LAPACK routines for general matrices.

Definition

Namespace: Numerics.NET.LinearAlgebra.Implementation
Assembly: Numerics.NET (in Numerics.NET.dll) Version: 9.0.3

public abstract class DecompositionOperations<TReal, TComplex> : IImplementation, 
	IParallelized

Visual Basic

Public MustInherit Class DecompositionOperations(Of TReal, TComplex)
	Implements IImplementation, IParallelized

C++/CLI

generic<typename TReal, typename TComplex>
public ref class DecompositionOperations abstract : IImplementation, 
	IParallelized

[<AbstractClassAttribute>]
type DecompositionOperations<'TReal, 'TComplex> = 
    class
        interface IImplementation
        interface IParallelized
    end

Inheritance: Object → DecompositionOperations<TReal, TComplex>

Derived: Numerics.NET.LinearAlgebra.Implementation.DecompositionOperations<T>

Implements: IParallelized, IImplementation

Type Parameters

TReal
TComplex

Remarks

The Linear Algebra PACKage (LAPACK) is the de facto standard for more complex linear algebra problems. It complements the Basic Linear Algebra Subroutines (BLAS), which defines standards for low level vector and matrix operations.

Constructors

DecompositionOperations<TReal, TComplex>

Initializes a new instance of the DecompositionOperations<TReal, TComplex> class

Properties

HasSharedDegreeOfParallelism	Indicates whether the degree of parallelism is a property that is shared across instances.
ImplementedType	Gets the base type of the implementation.
MaxDegreeOfParallelism	Gets or sets the maximum degree of parallelism enabled by the instance.
Name	Gets the name of the implementation.
Platform	Gets the processor architecture supported by the implementation.

Methods

BandCholeskyDecompose(MatrixTriangle, Int32, Int32, Array2D<TReal>, Int32)	Computes the Cholesky factorization of a real symmetric positive definite band matrix A.
BandCholeskyDecompose(MatrixTriangle, Int32, Int32, Array2D<TComplex>, Int32)	Computes the Cholesky factorization of a complex Hermitian positive definite band matrix A.
BandCholeskyDecompose(MatrixTriangle, Int32, Int32, Span2D<TReal>, Int32)	Computes the Cholesky factorization of a real symmetric positive definite band matrix A.
BandCholeskyDecompose(MatrixTriangle, Int32, Int32, Span2D<TComplex>, Int32)	Computes the Cholesky factorization of a complex Hermitian positive definite band matrix A.
BandCholeskyDecompose(MatrixTriangle, Int32, Int32, Span<TReal>, Int32, Int32)	Computes the Cholesky factorization of a real symmetric positive definite band matrix A.
BandCholeskyDecompose(MatrixTriangle, Int32, Int32, Span<TComplex>, Int32, Int32)	Computes the Cholesky factorization of a complex Hermitian positive definite band matrix A.
BandCholeskyEstimateCondition(MatrixTriangle, Int32, Int32, Array2D<TReal>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite band matrix using the Cholesky factorization A = U^TU or A = LL^T computed by DPBTRF.
BandCholeskyEstimateCondition(MatrixTriangle, Int32, Int32, Array2D<TComplex>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite band matrix using the Cholesky factorization A = U^HU or A = LL^H computed by ZPBTRF.
BandCholeskyEstimateCondition(MatrixTriangle, Int32, Int32, ReadOnlySpan2D<TComplex>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite band matrix using the Cholesky factorization A = U^HU or A = LL^H computed by ZPBTRF.
BandCholeskyEstimateCondition(MatrixTriangle, Int32, Int32, Span2D<TReal>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite band matrix using the Cholesky factorization A = U^TU or A = LL^T computed by DPBTRF.
BandCholeskyEstimateCondition(MatrixTriangle, Int32, Int32, ReadOnlySpan<TComplex>, Int32, TReal, TReal, Int32)	Estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite band matrix using the Cholesky factorization A = U^HU or A = LL^H computed by ZPBTRF.
BandCholeskyEstimateCondition(MatrixTriangle, Int32, Int32, Span<TReal>, Int32, TReal, TReal, Int32)	Estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite band matrix using the Cholesky factorization A = U^TU or A = LL^T computed by DPBTRF.
BandCholeskySolve(MatrixTriangle, Int32, Int32, Int32, Array2D<TReal>, Array2D<TReal>, Int32)	Solves a system of linear equations AX = B with a symmetric positive definite band matrix A using the Cholesky factorization A = U^TU or A = L*L^T computed by DPBTRF.
BandCholeskySolve(MatrixTriangle, Int32, Int32, Int32, Array2D<TComplex>, Array2D<TComplex>, Int32)	Solves a system of linear equations AX = B with a Hermitian positive definite band matrix A using the Cholesky factorization A = U^H U or A = L*L^H computed by ZPBTRF.
BandCholeskySolve(MatrixTriangle, Int32, Int32, Int32, ReadOnlySpan2D<TComplex>, Span2D<TComplex>, Int32)	Solves a system of linear equations AX = B with a Hermitian positive definite band matrix A using the Cholesky factorization A = U^H U or A = L*L^H computed by ZPBTRF.
BandCholeskySolve(MatrixTriangle, Int32, Int32, Int32, Span2D<TReal>, Span2D<TReal>, Int32)	Solves a system of linear equations AX = B with a symmetric positive definite band matrix A using the Cholesky factorization A = U^TU or A = L*L^T computed by DPBTRF.
BandCholeskySolve(MatrixTriangle, Int32, Int32, Int32, ReadOnlySpan<TComplex>, Int32, Span<TComplex>, Int32, Int32)	Solves a system of linear equations AX = B with a Hermitian positive definite band matrix A using the Cholesky factorization A = U^H U or A = L*L^H computed by ZPBTRF.
BandCholeskySolve(MatrixTriangle, Int32, Int32, Int32, Span<TReal>, Int32, Span<TReal>, Int32, Int32)	Solves a system of linear equations AX = B with a symmetric positive definite band matrix A using the Cholesky factorization A = U^TU or A = L*L^T computed by DPBTRF.
BandLUDecompose(Int32, Int32, Int32, Int32, Array2D<TReal>, Array1D<Int32>, Int32)	Computes an LU factorization of a real m-by-n band matrix A using partial pivoting with row interchanges.
BandLUDecompose(Int32, Int32, Int32, Int32, Array2D<TComplex>, Array1D<Int32>, Int32)	Computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges.
BandLUDecompose(Int32, Int32, Int32, Int32, Span2D<TReal>, Span<Int32>, Int32)	Computes an LU factorization of a real m-by-n band matrix A using partial pivoting with row interchanges.
BandLUDecompose(Int32, Int32, Int32, Int32, Span2D<TComplex>, Span<Int32>, Int32)	Computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges.
BandLUDecompose(Int32, Int32, Int32, Int32, Span<TReal>, Int32, Span<Int32>, Int32)	Computes an LU factorization of a real m-by-n band matrix A using partial pivoting with row interchanges.
BandLUDecompose(Int32, Int32, Int32, Int32, Span<TComplex>, Int32, Span<Int32>, Int32)	Computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges.
BandLUEstimateCondition(MatrixNorm, Int32, Int32, Int32, Array2D<TReal>, Array1D<Int32>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number of a real general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by DGBTRF.
BandLUEstimateCondition(MatrixNorm, Int32, Int32, Int32, Array2D<TComplex>, Array1D<Int32>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number of a complex general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by ZGBTRF.
BandLUEstimateCondition(MatrixNorm, Int32, Int32, Int32, ReadOnlySpan2D<TReal>, Span<Int32>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number of a real general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by DGBTRF.
BandLUEstimateCondition(MatrixNorm, Int32, Int32, Int32, ReadOnlySpan2D<TComplex>, Span<Int32>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number of a complex general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by ZGBTRF.
BandLUEstimateCondition(MatrixNorm, Int32, Int32, Int32, ReadOnlySpan<TReal>, Int32, Span<Int32>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number of a real general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by DGBTRF.
BandLUEstimateCondition(MatrixNorm, Int32, Int32, Int32, ReadOnlySpan<TComplex>, Int32, Span<Int32>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number of a complex general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by ZGBTRF.
BandLUSolve(TransposeOperation, Int32, Int32, Int32, Int32, Array2D<TReal>, Array1D<Int32>, Array2D<TReal>, Int32)	Solves a system of linear equations A * X = B or A^T * X = B with a general band matrix A using the LU factorization computed by DGBTRF.
BandLUSolve(TransposeOperation, Int32, Int32, Int32, Int32, Array2D<TComplex>, Array1D<Int32>, Array2D<TComplex>, Int32)	Solves a system of linear equations A * X = B, A^T * X = B, or A^H * X = B with a general band matrix A using the LU factorization computed by ZGBTRF.
BandLUSolve(TransposeOperation, Int32, Int32, Int32, Int32, Span2D<TReal>, Span<Int32>, Span2D<TReal>, Int32)	Solves a system of linear equations A * X = B or A^T * X = B with a general band matrix A using the LU factorization computed by DGBTRF.
BandLUSolve(TransposeOperation, Int32, Int32, Int32, Int32, Span2D<TComplex>, Span<Int32>, Span2D<TComplex>, Int32)	Solves a system of linear equations A * X = B, A^T * X = B, or A^H * X = B with a general band matrix A using the LU factorization computed by ZGBTRF.
BandLUSolve(TransposeOperation, Int32, Int32, Int32, Int32, Span<TReal>, Int32, Span<Int32>, Span<TReal>, Int32, Int32)	Solves a system of linear equations A * X = B or A^T * X = B with a general band matrix A using the LU factorization computed by DGBTRF.
BandLUSolve(TransposeOperation, Int32, Int32, Int32, Int32, Span<TComplex>, Int32, Span<Int32>, Span<TComplex>, Int32, Int32)	Solves a system of linear equations A * X = B, A^T * X = B, or A^H * X = B with a general band matrix A using the LU factorization computed by ZGBTRF.
BandTriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Int32, Array2D<TReal>, Array2D<TReal>, Int32)	Solves a triangular system of the form A * X = B or A^T * X = B, where A is a triangular band matrix of order N, and B is an N-by NRHS matrix.
BandTriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Int32, ReadOnlySpan2D<TReal>, Span2D<TReal>, Int32)	Solves a triangular system of the form A * X = B or A^T * X = B, where A is a triangular band matrix of order N, and B is an N-by NRHS matrix.
BandTriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Int32, ReadOnlySpan<TReal>, Int32, Span<TReal>, Int32, Int32)	Solves a triangular system of the form A * X = B or A^T * X = B, where A is a triangular band matrix of order N, and B is an N-by NRHS matrix.
CholeskyDecompose(MatrixTriangle, Int32, Array2D<TReal>, Int32)	Computes the Cholesky factorization of a real symmetric positive definite matrix A.
CholeskyDecompose(MatrixTriangle, Int32, Array2D<TComplex>, Int32)	Factors a symmetric positive definite matrix.
CholeskyDecompose(MatrixTriangle, Int32, Span2D<TReal>, Int32)	Computes the Cholesky factorization of a real symmetric positive definite matrix A.
CholeskyDecompose(MatrixTriangle, Int32, Span2D<TComplex>, Int32)	Factors a symmetric positive definite matrix.
CholeskyDecompose(MatrixTriangle, Int32, Span<TReal>, Int32, Int32)	Computes the Cholesky factorization of a real symmetric positive definite matrix A.
CholeskyDecompose(MatrixTriangle, Int32, Span<TComplex>, Int32, Int32)	Factors a symmetric positive definite matrix.
CholeskyEstimateCondition(MatrixTriangle, Int32, Array2D<TReal>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite matrix using the Cholesky factorization A = U^TU or A = LL^T computed by DPOTRF.
CholeskyEstimateCondition(MatrixTriangle, Int32, Array2D<TComplex>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number of a factored hermitian matrix.
CholeskyEstimateCondition(MatrixTriangle, Int32, ReadOnlySpan2D<TReal>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite matrix using the Cholesky factorization A = U^TU or A = LL^T computed by DPOTRF.
CholeskyEstimateCondition(MatrixTriangle, Int32, ReadOnlySpan2D<TComplex>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number of a factored hermitian matrix.
CholeskyEstimateCondition(MatrixTriangle, Int32, ReadOnlySpan<TReal>, Int32, TReal, TReal, Int32)	Estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite matrix using the Cholesky factorization A = U^TU or A = LL^T computed by DPOTRF.
CholeskyEstimateCondition(MatrixTriangle, Int32, ReadOnlySpan<TComplex>, Int32, TReal, TReal, Int32)	Estimates the reciprocal of the condition number of a factored hermitian matrix.
CholeskyInvert(MatrixTriangle, Int32, Array2D<TReal>, Int32)	Computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = U^TU or A = LL^T computed by DPOTRF.
CholeskyInvert(MatrixTriangle, Int32, Array2D<TComplex>, Int32)	Computes the inverse of a factored hermitian matrix.
CholeskyInvert(MatrixTriangle, Int32, Span2D<TReal>, Int32)	Computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = U^TU or A = LL^T computed by DPOTRF.
CholeskyInvert(MatrixTriangle, Int32, Span2D<TComplex>, Int32)	Computes the inverse of a factored hermitian matrix.
CholeskyInvert(MatrixTriangle, Int32, Span<TReal>, Int32, Int32)	Computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = U^TU or A = LL^T computed by DPOTRF.
CholeskyInvert(MatrixTriangle, Int32, Span<TComplex>, Int32, Int32)	Computes the inverse of a factored hermitian matrix.
CholeskySolve(MatrixTriangle, Int32, Int32, Array2D<TReal>, Array2D<TReal>, Int32)	Solves a system of linear equations AX = B with a symmetric positive definite matrix A using the Cholesky factorization A = U^TU or A = L*L^T computed by DPOTRF.
CholeskySolve(MatrixTriangle, Int32, Int32, Array2D<TComplex>, Array2D<TComplex>, Int32)	Solves a hermitian system of equations.
CholeskySolve(MatrixTriangle, Int32, Int32, ReadOnlySpan2D<TReal>, Span2D<TReal>, Int32)	Solves a system of linear equations AX = B with a symmetric positive definite matrix A using the Cholesky factorization A = U^TU or A = L*L^T computed by DPOTRF.
CholeskySolve(MatrixTriangle, Int32, Int32, ReadOnlySpan2D<TComplex>, Span2D<TComplex>, Int32)	Solves a hermitian system of equations.
CholeskySolve(MatrixTriangle, Int32, Int32, ReadOnlySpan<TReal>, Int32, Span<TReal>, Int32, Int32)	Solves a system of linear equations AX = B with a symmetric positive definite matrix A using the Cholesky factorization A = U^TU or A = L*L^T computed by DPOTRF.
CholeskySolve(MatrixTriangle, Int32, Int32, ReadOnlySpan<TComplex>, Int32, Span<TComplex>, Int32, Int32)	Solves a hermitian system of equations.
EigenvalueDecompose(Char, Char, Int32, Array2D<TComplex>, Array1D<TComplex>, Array2D<TComplex>, Array2D<TComplex>, Int32)	Computes for an N-by-N complex non-symmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors.
EigenvalueDecompose(Char, Char, Int32, Span2D<TComplex>, Span<TComplex>, Span2D<TComplex>, Span2D<TComplex>, Int32)	Computes for an N-by-N complex non-symmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors.
EigenvalueDecompose(Char, Char, Int32, Array2D<TReal>, Array1D<TReal>, Array1D<TReal>, Array2D<TReal>, Array2D<TReal>, Int32)	Computes for an N-by-N real non-symmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors.
EigenvalueDecompose(Char, Char, Int32, Span2D<TReal>, Span<TReal>, Span<TReal>, Span2D<TReal>, Span2D<TReal>, Int32)	Computes for an N-by-N real non-symmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors.
EigenvalueDecompose(Char, Char, Int32, Span<TComplex>, Int32, Span<TComplex>, Span<TComplex>, Int32, Span<TComplex>, Int32, Int32)	Computes for an N-by-N complex non-symmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors.
EigenvalueDecompose(Char, Char, Int32, Span<TReal>, Int32, Span<TReal>, Span<TReal>, Span<TReal>, Int32, Span<TReal>, Int32, Int32)	Computes for an N-by-N real non-symmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors.
Equals	Determines whether the specified object is equal to the current object. (Inherited from Object)
Finalize	Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. (Inherited from Object)
GeneralizedEigenvalueDecompose(Char, Char, Int32, Array2D<TComplex>, Array2D<TComplex>, Array1D<TComplex>, Array1D<TComplex>, Array2D<TComplex>, Array2D<TComplex>, Int32)	Computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors.
GeneralizedEigenvalueDecompose(Char, Char, Int32, Span2D<TComplex>, Span2D<TComplex>, Span<TComplex>, Span<TComplex>, Span2D<TComplex>, Span2D<TComplex>, Int32)	Computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors.
GeneralizedEigenvalueDecompose(Char, Char, Int32, Array2D<TReal>, Array2D<TReal>, Array1D<TReal>, Array1D<TReal>, Array1D<TReal>, Array2D<TReal>, Array2D<TReal>, Int32)	Computes for a pair of N-by-N real nonsymmetric matrices (A,B) the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors.
GeneralizedEigenvalueDecompose(Char, Char, Int32, Span2D<TReal>, Span2D<TReal>, Span<TReal>, Span<TReal>, Span<TReal>, Span2D<TReal>, Span2D<TReal>, Int32)	Computes for a pair of N-by-N real nonsymmetric matrices (A,B) the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors.
GeneralizedEigenvalueDecompose(Char, Char, Int32, Span<TComplex>, Int32, Span<TComplex>, Int32, Span<TComplex>, Span<TComplex>, Span<TComplex>, Int32, Span<TComplex>, Int32, Int32)	Computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors.
GeneralizedEigenvalueDecompose(Char, Char, Int32, Span<TReal>, Int32, Span<TReal>, Int32, Span<TReal>, Span<TReal>, Span<TReal>, Span<TReal>, Int32, Span<TReal>, Int32, Int32)	Computes for a pair of N-by-N real nonsymmetric matrices (A,B) the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors.
GeneralizedSchurDecompose(Char, Char, Char, Func<TComplex, TComplex, Boolean>, Int32, Span<TComplex>, Int32, Span<TComplex>, Int32, Int32, Span<TComplex>, Span<TComplex>, Span<TComplex>, Int32, Span<TComplex>, Int32, Int32)	C# `Computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, the generalized complex Schur form (S, T), and optionally left and/or right Schur vectors (VSL and VSR).`
GeneralizedSchurDecompose(Char, Char, Char, Func<TReal, TReal, TReal, Boolean>, Int32, Span<TReal>, Int32, Span<TReal>, Int32, Int32, Span<TReal>, Span<TReal>, Span<TReal>, Span<TReal>, Int32, Span<TReal>, Int32, Int32)	C# `Computes for a pair of N-by-N real nonsymmetric matrices (A,B), the generalized eigenvalues, the generalized real Schur form (S,T), optionally, the left and/or right matrices of Schur vectors (VSL and VSR).`
GeneralizedSingularValueDecompose(Char, Char, Char, Int32, Int32, Int32, Int32, Int32, Array2D<TReal>, Array2D<TReal>, Array1D<TReal>, Array1D<TReal>, Array2D<TReal>, Array2D<TReal>, Array2D<TReal>, Array1D<Int32>, Int32)	Computes the generalized singular value decomposition (GSVD) of an M-by-N real matrix A and P-by-N real matrix B: U*TAQ = D1( 0 R ), V*TBQ = D2( 0 R ) where U, V and Q are orthogonal matrices.
GeneralizedSingularValueDecompose(Char, Char, Char, Int32, Int32, Int32, Int32, Int32, Array2D<TComplex>, Array2D<TComplex>, Array1D<TReal>, Array1D<TReal>, Array2D<TComplex>, Array2D<TComplex>, Array2D<TComplex>, Array1D<Int32>, Int32)	Computes the generalized singular value decomposition (GSVD) of an M-by-N complex matrix A and P-by-N complex matrix B: U*HAQ = D1( 0 R ), V*HBQ = D2( 0 R ) where U, V and Q are unitary matrices.
GeneralizedSingularValueDecompose(Char, Char, Char, Int32, Int32, Int32, Int32, Int32, Span2D<TReal>, Span2D<TReal>, Span<TReal>, Span<TReal>, Span2D<TReal>, Span2D<TReal>, Span2D<TReal>, Span<Int32>, Int32)	Computes the generalized singular value decomposition (GSVD) of an M-by-N real matrix A and P-by-N real matrix B: U*TAQ = D1( 0 R ), V*TBQ = D2( 0 R ) where U, V and Q are orthogonal matrices.
GeneralizedSingularValueDecompose(Char, Char, Char, Int32, Int32, Int32, Int32, Int32, Span2D<TComplex>, Span2D<TComplex>, Span<TReal>, Span<TReal>, Span2D<TComplex>, Span2D<TComplex>, Span2D<TComplex>, Span<Int32>, Int32)	Computes the generalized singular value decomposition (GSVD) of an M-by-N complex matrix A and P-by-N complex matrix B: U*HAQ = D1( 0 R ), V*HBQ = D2( 0 R ) where U, V and Q are unitary matrices.
GeneralizedSingularValueDecompose(Char, Char, Char, Int32, Int32, Int32, Int32, Int32, Span<TReal>, Int32, Span<TReal>, Int32, Span<TReal>, Span<TReal>, Span<TReal>, Int32, Span<TReal>, Int32, Span<TReal>, Int32, Span<Int32>, Int32)	Computes the generalized singular value decomposition (GSVD) of an M-by-N real matrix A and P-by-N real matrix B: U*TAQ = D1( 0 R ), V*TBQ = D2( 0 R ) where U, V and Q are orthogonal matrices.
GeneralizedSingularValueDecompose(Char, Char, Char, Int32, Int32, Int32, Int32, Int32, Span<TComplex>, Int32, Span<TComplex>, Int32, Span<TReal>, Span<TReal>, Span<TComplex>, Int32, Span<TComplex>, Int32, Span<TComplex>, Int32, Span<Int32>, Int32)	Computes the generalized singular value decomposition (GSVD) of an M-by-N complex matrix A and P-by-N complex matrix B: U*HAQ = D1( 0 R ), V*HBQ = D2( 0 R ) where U, V and Q are unitary matrices.
GetHashCode	Serves as the default hash function. (Inherited from Object)
GetType	Gets the Type of the current instance. (Inherited from Object)
HermitianDecompose(MatrixTriangle, Int32, Array2D<TComplex>, Array1D<Int32>, Int32)	Computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method.
HermitianDecompose(MatrixTriangle, Int32, Span2D<TComplex>, Span<Int32>, Int32)	Computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method.
HermitianDecompose(MatrixTriangle, Int32, Span<TComplex>, Int32, Span<Int32>, Int32)	Computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method.
HermitianEigenvalueDecompose(Char, MatrixTriangle, Int32, Array2D<TComplex>, Array1D<TReal>, Int32)	Computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.
HermitianEigenvalueDecompose(Char, MatrixTriangle, Int32, Span2D<TComplex>, Span<TReal>, Int32)	Computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.
HermitianEigenvalueDecompose(Char, MatrixTriangle, Int32, Span<TComplex>, Int32, Span<TReal>, Int32)	Computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.
HermitianEstimateCondition(MatrixTriangle, Int32, Array2D<TComplex>, Array1D<Int32>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = UDU^H or A = LDL^H computed by ZHETRF.
HermitianEstimateCondition(MatrixTriangle, Int32, ReadOnlySpan2D<TComplex>, Span<Int32>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = UDU^H or A = LDL^H computed by ZHETRF.
HermitianEstimateCondition(MatrixTriangle, Int32, ReadOnlySpan<TComplex>, Int32, ReadOnlySpan<Int32>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = UDU^H or A = LDL^H computed by ZHETRF.
HermitianGeneralizedEigenvalueDecompose(Int32, Char, MatrixTriangle, Int32, Array2D<TComplex>, Array2D<TComplex>, Array1D<TReal>, Int32)	Computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x.
HermitianGeneralizedEigenvalueDecompose(Int32, Char, MatrixTriangle, Int32, Span2D<TComplex>, Span2D<TComplex>, Span<TReal>, Int32)	Computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x.
HermitianGeneralizedEigenvalueDecompose(Int32, Char, MatrixTriangle, Int32, Span<TComplex>, Int32, Span<TComplex>, Int32, Span<TReal>, Int32)	Computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x.
HermitianInvert(MatrixTriangle, Int32, Array2D<TComplex>, Array1D<Int32>, Int32)	Computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDU^H or A = LDL^H computed by ZHETRF.
HermitianInvert(MatrixTriangle, Int32, Span2D<TComplex>, Span<Int32>, Int32)	Computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDU^H or A = LDL^H computed by ZHETRF.
HermitianInvert(MatrixTriangle, Int32, Span<TComplex>, Int32, ReadOnlySpan<Int32>, Int32)	Computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = UDU^H or A = LDL^H computed by ZHETRF.
HermitianSolve(MatrixTriangle, Int32, Int32, Array2D<TComplex>, Array1D<Int32>, Array2D<TComplex>, Int32)	Solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDU^H or A = LD*L^H computed by ZHETRF.
HermitianSolve(MatrixTriangle, Int32, Int32, ReadOnlySpan2D<TComplex>, Span<Int32>, Span2D<TComplex>, Int32)	Solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDU^H or A = LD*L^H computed by ZHETRF.
HermitianSolve(MatrixTriangle, Int32, Int32, ReadOnlySpan<TComplex>, Int32, ReadOnlySpan<Int32>, Span<TComplex>, Int32, Int32)	Solves a system of linear equations AX = B with a complex Hermitian matrix A using the factorization A = UDU^H or A = LD*L^H computed by ZHETRF.
LQDecompose(Int32, Int32, Array2D<TReal>, Array1D<TReal>, Int32)	Computes an LQ factorization of a real M-by-N matrix A: A = L * Q.
LQDecompose(Int32, Int32, Array2D<TComplex>, Array1D<TComplex>, Int32)	Computes an LQ factorization of a complex M-by-N matrix A: A = L * Q.
LQDecompose(Int32, Int32, Span2D<TReal>, Span<TReal>, Int32)	Computes an LQ factorization of a real M-by-N matrix A: A = L * Q.
LQDecompose(Int32, Int32, Span2D<TComplex>, Span<TComplex>, Int32)	Computes an LQ factorization of a complex M-by-N matrix A: A = L * Q.
LQDecompose(Int32, Int32, Span<TReal>, Int32, Span<TReal>, Int32)	Computes an LQ factorization of a real M-by-N matrix A: A = L * Q.
LQDecompose(Int32, Int32, Span<TComplex>, Int32, Span<TComplex>, Int32)	Computes an LQ factorization of a complex M-by-N matrix A: A = L * Q.
LQOrthogonalMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2D<TReal>, Array1D<TReal>, Array2D<TReal>, Int32)	Overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) .
LQOrthogonalMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Span2D<TReal>, ReadOnlySpan<TReal>, Span2D<TReal>, Int32)	Overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) .
LQOrthogonalMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Span<TReal>, Int32, ReadOnlySpan<TReal>, Span<TReal>, Int32, Int32)	Overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) .
LQUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2D<TComplex>, Array1D<TComplex>, Array2D<TComplex>, Int32)	Overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k)H .
LQUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Span2D<TComplex>, ReadOnlySpan<TComplex>, Span2D<TComplex>, Int32)	Overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k)H .
LQUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Span<TComplex>, Int32, ReadOnlySpan<TComplex>, Span<TComplex>, Int32, Int32)	Overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k)H .
LUDecompose(Int32, Int32, Array2D<TReal>, Array1D<Int32>, Int32)	Computes an LU decomposition of a general M-by-N matrix A using partial pivoting with row interchanges. The decomposition has the form A = P * L * U. where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.
LUDecompose(Int32, Int32, Array2D<TComplex>, Array1D<Int32>, Int32)	ZGETRF computes an LU decomposition of a general M-by-N matrix A using partial pivoting with row interchanges. The decomposition has the form A = P * L * U. where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.
LUDecompose(Int32, Int32, Span2D<TReal>, Span<Int32>, Int32)	Computes an LU decomposition of a general M-by-N matrix A using partial pivoting with row interchanges. The decomposition has the form A = P * L * U. where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.
LUDecompose(Int32, Int32, Span2D<TComplex>, Span<Int32>, Int32)	ZGETRF computes an LU decomposition of a general M-by-N matrix A using partial pivoting with row interchanges. The decomposition has the form A = P * L * U. where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.
LUDecompose(Int32, Int32, Span<TReal>, Int32, Span<Int32>, Int32)	Computes an LU decomposition of a general M-by-N matrix A using partial pivoting with row interchanges. The decomposition has the form A = P * L * U. where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.
LUDecompose(Int32, Int32, Span<TComplex>, Int32, Span<Int32>, Int32)	ZGETRF computes an LU decomposition of a general M-by-N matrix A using partial pivoting with row interchanges. The decomposition has the form A = P * L * U. where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). This is the right-looking Level 3 BLAS version of the algorithm.
LUEstimateCondition(MatrixNorm, Int32, Array2D<TReal>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number of a general real matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by DGETRF.
LUEstimateCondition(MatrixNorm, Int32, Array2D<TComplex>, TReal, TReal, Int32)	ZGECON estimates the reciprocal of the condition number of a general real matrix A, inthis. either the 1-norm or the infinity-norm, using the LU decomposition computed by ZGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ). Arguments ========= NORM (input) CHARACTER1 Specifies whether the 1-norm condition number or the infinity-norm condition number is required: = '1' or 'O': 1-norm; = 'I': Infinity-norm. N (input) INTEGER The elementOrder of the matrix A. N >= 0. A (input) DOUBLE PRECISION array, dimension (LDA,N) The factors L and U from the decomposition A = PLU as computed by ZGETRF. LDA (input) INTEGER The leading dimension of the array A. LDA >= Max(1,N). ANORM (input) DOUBLE PRECISION If NORM = '1' or 'O', the 1-norm of the original matrix A. If NORM = 'I', the infinity-norm of the original matrix A. RCOND (output) DOUBLE PRECISION The reciprocal of the condition number of the matrix A, computed as RCOND = 1/(norm(A) norm(inv(A))). WORK (workspace) DOUBLE PRECISION array, dimension (4*N) IWORK (workspace) INTEGER array, dimension (N) INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
LUEstimateCondition(MatrixNorm, Int32, Span2D<TReal>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number of a general real matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by DGETRF.
LUEstimateCondition(MatrixNorm, Int32, Span2D<TComplex>, TReal, TReal, Int32)	ZGECON estimates the reciprocal of the condition number of a general real matrix A, inthis. either the 1-norm or the infinity-norm, using the LU decomposition computed by ZGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ). Arguments ========= NORM (input) CHARACTER1 Specifies whether the 1-norm condition number or the infinity-norm condition number is required: = '1' or 'O': 1-norm; = 'I': Infinity-norm. N (input) INTEGER The elementOrder of the matrix A. N >= 0. A (input) DOUBLE PRECISION array, dimension (LDA,N) The factors L and U from the decomposition A = PLU as computed by ZGETRF. LDA (input) INTEGER The leading dimension of the array A. LDA >= Max(1,N). ANORM (input) DOUBLE PRECISION If NORM = '1' or 'O', the 1-norm of the original matrix A. If NORM = 'I', the infinity-norm of the original matrix A. RCOND (output) DOUBLE PRECISION The reciprocal of the condition number of the matrix A, computed as RCOND = 1/(norm(A) norm(inv(A))). WORK (workspace) DOUBLE PRECISION array, dimension (4*N) IWORK (workspace) INTEGER array, dimension (N) INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
LUEstimateCondition(MatrixNorm, Int32, Span<TReal>, Int32, TReal, TReal, Int32)	Estimates the reciprocal of the condition number of a general real matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by DGETRF.
LUEstimateCondition(MatrixNorm, Int32, Span<TComplex>, Int32, TReal, TReal, Int32)	ZGECON estimates the reciprocal of the condition number of a general real matrix A, inthis. either the 1-norm or the infinity-norm, using the LU decomposition computed by ZGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ). Arguments ========= NORM (input) CHARACTER1 Specifies whether the 1-norm condition number or the infinity-norm condition number is required: = '1' or 'O': 1-norm; = 'I': Infinity-norm. N (input) INTEGER The elementOrder of the matrix A. N >= 0. A (input) DOUBLE PRECISION array, dimension (LDA,N) The factors L and U from the decomposition A = PLU as computed by ZGETRF. LDA (input) INTEGER The leading dimension of the array A. LDA >= Max(1,N). ANORM (input) DOUBLE PRECISION If NORM = '1' or 'O', the 1-norm of the original matrix A. If NORM = 'I', the infinity-norm of the original matrix A. RCOND (output) DOUBLE PRECISION The reciprocal of the condition number of the matrix A, computed as RCOND = 1/(norm(A) norm(inv(A))). WORK (workspace) DOUBLE PRECISION array, dimension (4*N) IWORK (workspace) INTEGER array, dimension (N) INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
LUInvert(Int32, Array2D<TReal>, Array1D<Int32>, Int32)	Computes the inverse of a matrix using the LU decomposition computed by LUDecompose(Int32, Int32, Span<TReal>, Int32, Span<Int32>, Int32).
LUInvert(Int32, Array2D<TComplex>, Array1D<Int32>, Int32)	ZGETRI computes the inverse of a matrix using the LU decomposition computed by ZGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)L = inv(U) for inv(A). Arguments ========= N (input) INTEGER The elementOrder of the matrix A. N >= 0. A (input/output) DOUBLE PRECISION array, dimension (LDA,N) On entry, the factors L and U from the decomposition A = PLU as computed by ZGETRF. On exit, if INFO = 0, the inverse of the original matrix A. LDA (input) INTEGER The leading dimension of the array A. LDA >= Max(1,N). IPIV (input) INTEGER array, dimension (N) The pivot indexes from ZGETRF; for 1< =i< =N, row i of the matrix was interchanged with row IPIVi. WORK (workspace/output) DOUBLE PRECISION array, dimension (LWORK) On exit, if INFO =0, then WORK(1) returns the optimal LWORK. LWORK (input) INTEGER The dimension of the array WORK. LWORK >= Max(1,N). For optimal performance LWORK >= NNB, where NB is the optimal blocksize returned by ILAENV. If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero; the matrix is singular and its inverse could not be computed.
LUInvert(Int32, Span2D<TReal>, Span<Int32>, Int32)	Computes the inverse of a matrix using the LU decomposition computed by LUDecompose(Int32, Int32, Span<TReal>, Int32, Span<Int32>, Int32).
LUInvert(Int32, Span2D<TComplex>, Span<Int32>, Int32)	ZGETRI computes the inverse of a matrix using the LU decomposition computed by ZGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)L = inv(U) for inv(A). Arguments ========= N (input) INTEGER The elementOrder of the matrix A. N >= 0. A (input/output) DOUBLE PRECISION array, dimension (LDA,N) On entry, the factors L and U from the decomposition A = PLU as computed by ZGETRF. On exit, if INFO = 0, the inverse of the original matrix A. LDA (input) INTEGER The leading dimension of the array A. LDA >= Max(1,N). IPIV (input) INTEGER array, dimension (N) The pivot indexes from ZGETRF; for 1< =i< =N, row i of the matrix was interchanged with row IPIVi. WORK (workspace/output) DOUBLE PRECISION array, dimension (LWORK) On exit, if INFO =0, then WORK(1) returns the optimal LWORK. LWORK (input) INTEGER The dimension of the array WORK. LWORK >= Max(1,N). For optimal performance LWORK >= NNB, where NB is the optimal blocksize returned by ILAENV. If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero; the matrix is singular and its inverse could not be computed.
LUInvert(Int32, Span<TReal>, Int32, Span<Int32>, Int32)	Computes the inverse of a matrix using the LU decomposition computed by LUDecompose(Int32, Int32, Span<TReal>, Int32, Span<Int32>, Int32).
LUInvert(Int32, Span<TComplex>, Int32, Span<Int32>, Int32)	ZGETRI computes the inverse of a matrix using the LU decomposition computed by ZGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)L = inv(U) for inv(A). Arguments ========= N (input) INTEGER The elementOrder of the matrix A. N >= 0. A (input/output) DOUBLE PRECISION array, dimension (LDA,N) On entry, the factors L and U from the decomposition A = PLU as computed by ZGETRF. On exit, if INFO = 0, the inverse of the original matrix A. LDA (input) INTEGER The leading dimension of the array A. LDA >= Max(1,N). IPIV (input) INTEGER array, dimension (N) The pivot indexes from ZGETRF; for 1< =i< =N, row i of the matrix was interchanged with row IPIVi. WORK (workspace/output) DOUBLE PRECISION array, dimension (LWORK) On exit, if INFO =0, then WORK(1) returns the optimal LWORK. LWORK (input) INTEGER The dimension of the array WORK. LWORK >= Max(1,N). For optimal performance LWORK >= NNB, where NB is the optimal blocksize returned by ILAENV. If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero; the matrix is singular and its inverse could not be computed.
LUSolve(TransposeOperation, Int32, Int32, Array2D<TReal>, Array1D<Int32>, Array2D<TReal>, Int32)	Solves a system of linear equations with a general N-by-N matrix A using the LU decomposition computed by LUDecompose(Int32, Int32, Span<TReal>, Int32, Span<Int32>, Int32).
LUSolve(TransposeOperation, Int32, Int32, Array2D<TComplex>, Array1D<Int32>, Array2D<TComplex>, Int32)	ZGETRS solves a system of linear equations A * X = B or A' * X = B with a general N-by-N matrix A using the LU decomposition computed by ZGETRF. Arguments ========= TRANS (input) CHARACTER1 Specifies the form of the system of equations: = 'N': A X = B (No transpose) = TransposeOperation.Transpose: A'* X = B (Transpose) = 'C': A'* X = B (Conjugate transpose = Transpose) N (input) INTEGER The elementOrder of the matrix A. N >= 0. NRHS (input) INTEGER The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A (input) DOUBLE PRECISION array, dimension (LDA,N) The factors L and U from the decomposition A = PLU as computed by ZGETRF. LDA (input) INTEGER The leading dimension of the array A. LDA >= Max(1,N). IPIV (input) INTEGER array, dimension (N) The pivot indexes from ZGETRF; for 1< =i< =N, row i of the matrix was interchanged with row IPIVi. B (input/output) DOUBLE PRECISION array, dimension (LDB,NRHS) On entry, the right hand side matrix B. On exit, the solution matrix X. LDB (input) INTEGER The leading dimension of the array B. LDB >= Max(1,N). INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value =====================================================================
LUSolve(TransposeOperation, Int32, Int32, Span2D<TReal>, Span<Int32>, Span2D<TReal>, Int32)	Solves a system of linear equations with a general N-by-N matrix A using the LU decomposition computed by LUDecompose(Int32, Int32, Span<TReal>, Int32, Span<Int32>, Int32).
LUSolve(TransposeOperation, Int32, Int32, Span2D<TComplex>, Span<Int32>, Span2D<TComplex>, Int32)	ZGETRS solves a system of linear equations A * X = B or A' * X = B with a general N-by-N matrix A using the LU decomposition computed by ZGETRF. Arguments ========= TRANS (input) CHARACTER1 Specifies the form of the system of equations: = 'N': A X = B (No transpose) = TransposeOperation.Transpose: A'* X = B (Transpose) = 'C': A'* X = B (Conjugate transpose = Transpose) N (input) INTEGER The elementOrder of the matrix A. N >= 0. NRHS (input) INTEGER The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A (input) DOUBLE PRECISION array, dimension (LDA,N) The factors L and U from the decomposition A = PLU as computed by ZGETRF. LDA (input) INTEGER The leading dimension of the array A. LDA >= Max(1,N). IPIV (input) INTEGER array, dimension (N) The pivot indexes from ZGETRF; for 1< =i< =N, row i of the matrix was interchanged with row IPIVi. B (input/output) DOUBLE PRECISION array, dimension (LDB,NRHS) On entry, the right hand side matrix B. On exit, the solution matrix X. LDB (input) INTEGER The leading dimension of the array B. LDB >= Max(1,N). INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value =====================================================================
LUSolve(TransposeOperation, Int32, Int32, Span<TReal>, Int32, Span<Int32>, Span<TReal>, Int32, Int32)	Solves a system of linear equations with a general N-by-N matrix A using the LU decomposition computed by LUDecompose(Int32, Int32, Span<TReal>, Int32, Span<Int32>, Int32).
LUSolve(TransposeOperation, Int32, Int32, Span<TComplex>, Int32, Span<Int32>, Span<TComplex>, Int32, Int32)	ZGETRS solves a system of linear equations A * X = B or A' * X = B with a general N-by-N matrix A using the LU decomposition computed by ZGETRF. Arguments ========= TRANS (input) CHARACTER1 Specifies the form of the system of equations: = 'N': A X = B (No transpose) = TransposeOperation.Transpose: A'* X = B (Transpose) = 'C': A'* X = B (Conjugate transpose = Transpose) N (input) INTEGER The elementOrder of the matrix A. N >= 0. NRHS (input) INTEGER The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A (input) DOUBLE PRECISION array, dimension (LDA,N) The factors L and U from the decomposition A = PLU as computed by ZGETRF. LDA (input) INTEGER The leading dimension of the array A. LDA >= Max(1,N). IPIV (input) INTEGER array, dimension (N) The pivot indexes from ZGETRF; for 1< =i< =N, row i of the matrix was interchanged with row IPIVi. B (input/output) DOUBLE PRECISION array, dimension (LDB,NRHS) On entry, the right hand side matrix B. On exit, the solution matrix X. LDB (input) INTEGER The leading dimension of the array B. LDB >= Max(1,N). INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value =====================================================================
MemberwiseClone	Creates a shallow copy of the current Object. (Inherited from Object)
QLDecompose(Int32, Int32, Array2D<TReal>, Array1D<TReal>, Int32)	Computes a QL factorization of a real M-by-N matrix A: A = Q * L.
QLDecompose(Int32, Int32, Array2D<TComplex>, Array1D<TComplex>, Int32)	Computes a QL factorization of a complex M-by-N matrix A: A = Q * L.
QLDecompose(Int32, Int32, Span2D<TReal>, Span<TReal>, Int32)	Computes a QL factorization of a real M-by-N matrix A: A = Q * L.
QLDecompose(Int32, Int32, Span2D<TComplex>, Span<TComplex>, Int32)	Computes a QL factorization of a complex M-by-N matrix A: A = Q * L.
QLDecompose(Int32, Int32, Span<TReal>, Int32, Span<TReal>, Int32)	Computes a QL factorization of a real M-by-N matrix A: A = Q * L.
QLDecompose(Int32, Int32, Span<TComplex>, Int32, Span<TComplex>, Int32)	Computes a QL factorization of a complex M-by-N matrix A: A = Q * L.
QLOrthogonalMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2D<TReal>, Array1D<TReal>, Array2D<TReal>, Int32)	Overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) .
QLOrthogonalMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Span2D<TReal>, ReadOnlySpan<TReal>, Span2D<TReal>, Int32)	Overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) .
QLOrthogonalMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Span<TReal>, Int32, ReadOnlySpan<TReal>, Span<TReal>, Int32, Int32)	Overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) .
QLUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2D<TComplex>, Array1D<TComplex>, Array2D<TComplex>, Int32)	Overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * Q**H where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k) .
QLUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Span2D<TComplex>, ReadOnlySpan<TComplex>, Span2D<TComplex>, Int32)	Overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * Q**H where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k) .
QLUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Span<TComplex>, Int32, ReadOnlySpan<TComplex>, Span<TComplex>, Int32, Int32)	Overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * Q**H where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k) .
QRDecompose(Int32, Int32, Array2D<TReal>, Array1D<TReal>, Int32)	Computes a QR factorization of a real M-by-N matrix A: A = Q * R.
QRDecompose(Int32, Int32, Array2D<TComplex>, Array1D<TComplex>, Int32)	ZGEQRF computes a QR decomposition of a real M-by-N matrix A: A = Q * R. Arguments ========= M (input) INTEGER The number of rows of the matrix A. M >= 0. N (input) INTEGER The number of columns of the matrix A. N >= 0. A (input/output) DOUBLE PRECISION array, dimension (LDA,N) On entry, the M-by-N matrix A. On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if m >= n); the elements below the diagonal, with the array TAU, represent the orthogonal matrix Q as a product of min(m,n) elementary reflectors (see Further Zetails). LDA (input) INTEGER The leading dimension of the array A. LDA >= max(1,M). TAU (output) DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Zetails). WORK (workspace/output) DOUBLE PRECISION array, dimension (LWORK) On exit, if INFO = 0, WORK(1) returns the optimal LWORK. LWORK (input) INTEGER The dimension of the array WORK. LWORK >= max(1,N). For optimum performance LWORK >= NNB, where NB is the optimal blocksize. If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value Further Zetails =============== The matrix Q is represented as a product of elementary reflectors Q = H(1) H(2) . . . H(k), where k = min(m,n). Each H(i) has the form H(i) = I - tau v * v' where tau is a real scalar, and v is a real vector with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit inthis. A(i+1:m,i), and tau inthis. TAU(i).
QRDecompose(Int32, Int32, Span2D<TReal>, Span<TReal>, Int32)	Computes a QR factorization of a real M-by-N matrix A: A = Q * R.
QRDecompose(Int32, Int32, Span2D<TComplex>, Span<TComplex>, Int32)	ZGEQRF computes a QR decomposition of a real M-by-N matrix A: A = Q * R. Arguments ========= M (input) INTEGER The number of rows of the matrix A. M >= 0. N (input) INTEGER The number of columns of the matrix A. N >= 0. A (input/output) DOUBLE PRECISION array, dimension (LDA,N) On entry, the M-by-N matrix A. On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if m >= n); the elements below the diagonal, with the array TAU, represent the orthogonal matrix Q as a product of min(m,n) elementary reflectors (see Further Zetails). LDA (input) INTEGER The leading dimension of the array A. LDA >= max(1,M). TAU (output) DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Zetails). WORK (workspace/output) DOUBLE PRECISION array, dimension (LWORK) On exit, if INFO = 0, WORK(1) returns the optimal LWORK. LWORK (input) INTEGER The dimension of the array WORK. LWORK >= max(1,N). For optimum performance LWORK >= NNB, where NB is the optimal blocksize. If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value Further Zetails =============== The matrix Q is represented as a product of elementary reflectors Q = H(1) H(2) . . . H(k), where k = min(m,n). Each H(i) has the form H(i) = I - tau v * v' where tau is a real scalar, and v is a real vector with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit inthis. A(i+1:m,i), and tau inthis. TAU(i).
QRDecompose(Int32, Int32, Array2D<TReal>, Array1D<Int32>, Array1D<TReal>, Int32)	Computes a QR factorization with column pivoting of a matrix A: AP = QR using Level 3 BLAS.
QRDecompose(Int32, Int32, Span2D<TReal>, Span<Int32>, Span<TReal>, Int32)	Computes a QR factorization with column pivoting of a matrix A: AP = QR using Level 3 BLAS.
QRDecompose(Int32, Int32, Span<TReal>, Int32, Span<TReal>, Int32)	Computes a QR factorization of a real M-by-N matrix A: A = Q * R.
QRDecompose(Int32, Int32, Span<TComplex>, Int32, Span<TComplex>, Int32)	ZGEQRF computes a QR decomposition of a real M-by-N matrix A: A = Q * R. Arguments ========= M (input) INTEGER The number of rows of the matrix A. M >= 0. N (input) INTEGER The number of columns of the matrix A. N >= 0. A (input/output) DOUBLE PRECISION array, dimension (LDA,N) On entry, the M-by-N matrix A. On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if m >= n); the elements below the diagonal, with the array TAU, represent the orthogonal matrix Q as a product of min(m,n) elementary reflectors (see Further Zetails). LDA (input) INTEGER The leading dimension of the array A. LDA >= max(1,M). TAU (output) DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Zetails). WORK (workspace/output) DOUBLE PRECISION array, dimension (LWORK) On exit, if INFO = 0, WORK(1) returns the optimal LWORK. LWORK (input) INTEGER The dimension of the array WORK. LWORK >= max(1,N). For optimum performance LWORK >= NNB, where NB is the optimal blocksize. If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value Further Zetails =============== The matrix Q is represented as a product of elementary reflectors Q = H(1) H(2) . . . H(k), where k = min(m,n). Each H(i) has the form H(i) = I - tau v * v' where tau is a real scalar, and v is a real vector with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit inthis. A(i+1:m,i), and tau inthis. TAU(i).
QRDecompose(Int32, Int32, Span<TReal>, Int32, Span<Int32>, Span<TReal>, Int32)	Computes a QR factorization with column pivoting of a matrix A: AP = QR using Level 3 BLAS.
QROrthogonalMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2D<TReal>, Array1D<TReal>, Array2D<TReal>, Int32)	Overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q^T * C C * Q^T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) .
QROrthogonalMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Span2D<TReal>, ReadOnlySpan<TReal>, Span2D<TReal>, Int32)	Overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q^T * C C * Q^T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) .
QROrthogonalMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Span<TReal>, Int32, ReadOnlySpan<TReal>, Span<TReal>, Int32, Int32)	Overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q^T * C C * Q^T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) .
QRUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2D<TComplex>, Array1D<TComplex>, Array2D<TComplex>, Int32)	Overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q^H * C C * Q^H where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) .
QRUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Span2D<TComplex>, ReadOnlySpan<TComplex>, Span2D<TComplex>, Int32)	Overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q^H * C C * Q^H where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) .
QRUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Span<TComplex>, Int32, ReadOnlySpan<TComplex>, Span<TComplex>, Int32, Int32)	Overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q^H * C C * Q^H where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) .
RQDecompose(Int32, Int32, Array2D<TReal>, Array1D<TReal>, Int32)	Computes an RQ factorization of a real M-by-N matrix A: A = R * Q.
RQDecompose(Int32, Int32, Array2D<TComplex>, Array1D<TComplex>, Int32)	Computes an RQ factorization of a complex M-by-N matrix A: A = R * Q.
RQDecompose(Int32, Int32, Span2D<TReal>, Span<TReal>, Int32)	Computes an RQ factorization of a real M-by-N matrix A: A = R * Q.
RQDecompose(Int32, Int32, Span2D<TComplex>, Span<TComplex>, Int32)	Computes an RQ factorization of a complex M-by-N matrix A: A = R * Q.
RQDecompose(Int32, Int32, Span<TReal>, Int32, Span<TReal>, Int32)	Computes an RQ factorization of a real M-by-N matrix A: A = R * Q.
RQDecompose(Int32, Int32, Span<TComplex>, Int32, Span<TComplex>, Int32)	Computes an RQ factorization of a complex M-by-N matrix A: A = R * Q.
RQOrthogonalMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2D<TReal>, Array1D<TReal>, Array2D<TReal>, Int32)	Overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) .
RQOrthogonalMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Span2D<TReal>, ReadOnlySpan<TReal>, Span2D<TReal>, Int32)	Overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) .
RQOrthogonalMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Span<TReal>, Int32, ReadOnlySpan<TReal>, Span<TReal>, Int32, Int32)	Overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) .
RQUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2D<TComplex>, Array1D<TComplex>, Array2D<TComplex>, Int32)	Overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1)H H(2)**H .
RQUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Span2D<TComplex>, ReadOnlySpan<TComplex>, Span2D<TComplex>, Int32)	Overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1)H H(2)**H .
RQUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Span<TComplex>, Int32, ReadOnlySpan<TComplex>, Span<TComplex>, Int32, Int32)	Overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1)H H(2)**H .
SchurDecompose(Char, Char, Func<TComplex, Boolean>, Int32, Span<TComplex>, Int32, Int32, Span<TComplex>, Span<TComplex>, Int32, Int32)	C# `Computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues, the Schur form T, and, optionally, the matrix of Schur vectors Z.`
SchurDecompose(Char, Char, Func<TReal, TReal, Boolean>, Int32, Span<TReal>, Int32, Int32, Span<TReal>, Span<TReal>, Span<TReal>, Int32, Int32)	C# `Computes for an N-by-N real nonsymmetric matrix A, the eigenvalues, the real Schur form T, and, optionally, the matrix of Schur vectors Z.`
SingularValueDecompose(Char, Int32, Int32, Array2D<TReal>, Array1D<TReal>, Array2D<TReal>, Array2D<TReal>, Int32)	Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and right singular vectors.
SingularValueDecompose(Char, Int32, Int32, Array2D<TComplex>, Array1D<TReal>, Array2D<TComplex>, Array2D<TComplex>, Int32)	Computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors, by using divide-and-conquer method.
SingularValueDecompose(Char, Int32, Int32, Span2D<TReal>, Span<TReal>, Span2D<TReal>, Span2D<TReal>, Int32)	Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and right singular vectors.
SingularValueDecompose(Char, Int32, Int32, Span2D<TComplex>, Span<TReal>, Span2D<TComplex>, Span2D<TComplex>, Int32)	Computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors, by using divide-and-conquer method.
SingularValueDecompose(Char, Int32, Int32, Span<TReal>, Int32, Span<TReal>, Span<TReal>, Int32, Span<TReal>, Int32, Int32)	Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and right singular vectors.
SingularValueDecompose(Char, Int32, Int32, Span<TComplex>, Int32, Span<TReal>, Span<TComplex>, Int32, Span<TComplex>, Int32, Int32)	Computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors, by using divide-and-conquer method.
SymmetricDecompose(MatrixTriangle, Int32, Array2D<TReal>, Array1D<Int32>, Int32)	Computes the factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method.
SymmetricDecompose(MatrixTriangle, Int32, Span2D<TReal>, Span<Int32>, Int32)	Computes the factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method.
SymmetricDecompose(MatrixTriangle, Int32, Span<TReal>, Int32, Span<Int32>, Int32)	Computes the factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method.
SymmetricEigenvalueDecompose(Char, MatrixTriangle, Int32, Array2D<TReal>, Array1D<TReal>, Int32)	Computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.
SymmetricEigenvalueDecompose(Char, MatrixTriangle, Int32, Span2D<TReal>, Span<TReal>, Int32)	Computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.
SymmetricEigenvalueDecompose(Char, MatrixTriangle, Int32, Span<TReal>, Int32, Span<TReal>, Int32)	Computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.
SymmetricEstimateCondition(MatrixTriangle, Int32, Array2D<TReal>, Array1D<Int32>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric matrix A using the factorization A = UDU^T or A = LDL^T computed by DSYTRF.
SymmetricEstimateCondition(MatrixTriangle, Int32, ReadOnlySpan2D<TReal>, ReadOnlySpan<Int32>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric matrix A using the factorization A = UDU^T or A = LDL^T computed by DSYTRF.
SymmetricEstimateCondition(MatrixTriangle, Int32, ReadOnlySpan<TReal>, Int32, ReadOnlySpan<Int32>, TReal, TReal, Int32)	Estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric matrix A using the factorization A = UDU^T or A = LDL^T computed by DSYTRF.
SymmetricGeneralizedEigenvalueDecompose(Int32, Char, MatrixTriangle, Int32, Array2D<TReal>, Array2D<TReal>, Array1D<TReal>, Int32)	Computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x.
SymmetricGeneralizedEigenvalueDecompose(Int32, Char, MatrixTriangle, Int32, Span2D<TReal>, Span2D<TReal>, Span<TReal>, Int32)	Computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x.
SymmetricGeneralizedEigenvalueDecompose(Int32, Char, MatrixTriangle, Int32, Span<TReal>, Int32, Span<TReal>, Int32, Span<TReal>, Int32)	Computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form Ax=(lambda)Bx, ABx=(lambda)x, or BAx=(lambda)x.
SymmetricInvert(MatrixTriangle, Int32, Array2D<TReal>, Array1D<Int32>, Int32)	Computes the inverse of a real symmetric indefinite matrix A using the factorization A = UDU^T or A = LDL^T computed by DSYTRF.
SymmetricInvert(MatrixTriangle, Int32, Span2D<TReal>, ReadOnlySpan<Int32>, Int32)	Computes the inverse of a real symmetric indefinite matrix A using the factorization A = UDU^T or A = LDL^T computed by DSYTRF.
SymmetricInvert(MatrixTriangle, Int32, Span<TReal>, Int32, ReadOnlySpan<Int32>, Int32)	Computes the inverse of a real symmetric indefinite matrix A using the factorization A = UDU^T or A = LDL^T computed by DSYTRF.
SymmetricSolve(MatrixTriangle, Int32, Int32, Array2D<TReal>, Array1D<Int32>, Array2D<TReal>, Int32)	Solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UDU^T or A = LD*L^T computed by DSYTRF.
SymmetricSolve(MatrixTriangle, Int32, Int32, ReadOnlySpan2D<TReal>, ReadOnlySpan<Int32>, Span2D<TReal>, Int32)	Solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UDU^T or A = LD*L^T computed by DSYTRF.
SymmetricSolve(MatrixTriangle, Int32, Int32, ReadOnlySpan<TReal>, Int32, ReadOnlySpan<Int32>, Span<TReal>, Int32, Int32)	Solves a system of linear equations AX = B with a real symmetric matrix A using the factorization A = UDU^T or A = LD*L^T computed by DSYTRF.
ToString	Returns a string that represents the current object. (Inherited from Object)
TriangularEstimateCondition(MatrixNorm, MatrixTriangle, MatrixDiagonal, Int32, Array2D<TReal>, TReal, Int32)	Estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm.
TriangularEstimateCondition(MatrixNorm, MatrixTriangle, MatrixDiagonal, Int32, Array2D<TComplex>, TReal, Int32)	Approximates the reciprocal of the condition number of a complex triangular matrix.
TriangularEstimateCondition(MatrixNorm, MatrixTriangle, MatrixDiagonal, Int32, ReadOnlySpan2D<TReal>, TReal, Int32)	Estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm.
TriangularEstimateCondition(MatrixNorm, MatrixTriangle, MatrixDiagonal, Int32, ReadOnlySpan2D<TComplex>, TReal, Int32)	Approximates the reciprocal of the condition number of a complex triangular matrix.
TriangularEstimateCondition(MatrixNorm, MatrixTriangle, MatrixDiagonal, Int32, ReadOnlySpan<TReal>, Int32, TReal, Int32)	Estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm.
TriangularEstimateCondition(MatrixNorm, MatrixTriangle, MatrixDiagonal, Int32, ReadOnlySpan<TComplex>, Int32, TReal, Int32)	Approximates the reciprocal of the condition number of a complex triangular matrix.
TriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Array2D<TReal>, Int32)	Computes the inverse of a real upper or lower triangular matrix A.
TriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Array2D<TComplex>, Int32)	Computes the inverse of a complex triangular matrix.
TriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Span2D<TReal>, Int32)	Computes the inverse of a real upper or lower triangular matrix A.
TriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Span2D<TComplex>, Int32)	Computes the inverse of a complex triangular matrix.
TriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Span<TReal>, Int32, Int32)	Computes the inverse of a real upper or lower triangular matrix A.
TriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Span<TComplex>, Int32, Int32)	Computes the inverse of a complex triangular matrix.
TriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Array2D<TReal>, Array2D<TReal>, Int32)	Solves a triangular system of the form A * X = B or A^T * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix.
TriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Array2D<TComplex>, Array2D<TComplex>, Int32)	Solves a complex triangular system of equations.
TriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, ReadOnlySpan2D<TReal>, Span2D<TReal>, Int32)	Solves a triangular system of the form A * X = B or A^T * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix.
TriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, ReadOnlySpan2D<TComplex>, Span2D<TComplex>, Int32)	Solves a complex triangular system of equations.
TriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, ReadOnlySpan<TReal>, Int32, Span<TReal>, Int32, Int32)	Solves a triangular system of the form A * X = B or A^T * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix.
TriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, ReadOnlySpan<TComplex>, Int32, Span<TComplex>, Int32, Int32)	Solves a complex triangular system of equations.