ManagedLapack Class

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

Definition

Namespace: Extreme.Mathematics.LinearAlgebra.Implementation
Assembly: Extreme.Numerics (in Extreme.Numerics.dll) Version: 8.1.23
C#
public sealed class ManagedLapack : DecompositionOperations<double>
Inheritance
Object  →  DecompositionOperations<Double, Complex<Double>>  →  DecompositionOperations<Double>  →  ManagedLapack

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.

Properties

HasSharedDegreeOfParallelism Indicates whether the degree of parallelism is a property that is shared across instances.
(Inherited from DecompositionOperations<TReal, TComplex>)
ImplementedType Gets the base type of the implementation.
(Inherited from DecompositionOperations<TReal, TComplex>)
MaxDegreeOfParallelism Gets or sets the maximum degree of parallelism enabled by the instance.
(Inherited from DecompositionOperations<TReal, TComplex>)
Name Gets the name of the implementation.
(Overrides DecompositionOperations<TReal, TComplex>.Name)
Platform Gets the processor architecture supported by the implementation.
(Overrides DecompositionOperations<TReal, TComplex>.Platform)

Methods

BandCholeskyDecompose(MatrixTriangle, Int32, Int32, Array2D<Complex<Double>>, Int32)

Computes the Cholesky factorization of a complex Hermitian positive definite band matrix A.


(Overrides DecompositionOperations<TReal, TComplex>.BandCholeskyDecompose(MatrixTriangle, Int32, Int32, Array2D<TComplex>, Int32))
BandCholeskyDecompose(MatrixTriangle, Int32, Int32, Array2D<Double>, Int32)

Computes the Cholesky factorization of a real symmetric positive definite band matrix A.


(Overrides DecompositionOperations<TReal, TComplex>.BandCholeskyDecompose(MatrixTriangle, Int32, Int32, Array2D<TReal>, Int32))
BandCholeskyEstimateCondition(MatrixTriangle, Int32, Int32, Array2D<Complex<Double>>, Double, Double, 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 = UH*U or A = L*LH computed by ZPBTRF.


(Overrides DecompositionOperations<TReal, TComplex>.BandCholeskyEstimateCondition(MatrixTriangle, Int32, Int32, Array2D<TComplex>, TReal, TReal, Int32))
BandCholeskyEstimateCondition(MatrixTriangle, Int32, Int32, Array2D<Double>, Double, Double, 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 = UT*U or A = L*LT computed by DPBTRF.


(Overrides DecompositionOperations<TReal, TComplex>.BandCholeskyEstimateCondition(MatrixTriangle, Int32, Int32, Array2D<TReal>, TReal, TReal, Int32))
BandCholeskySolve(MatrixTriangle, Int32, Int32, Int32, Array2D<Complex<Double>>, Array2D<Complex<Double>>, Int32)

Solves a system of linear equations A*X = B with a Hermitian positive definite band matrix A using the Cholesky factorization A = UH *U or A = L*LH computed by ZPBTRF.


(Overrides DecompositionOperations<TReal, TComplex>.BandCholeskySolve(MatrixTriangle, Int32, Int32, Int32, Array2D<TComplex>, Array2D<TComplex>, Int32))
BandCholeskySolve(MatrixTriangle, Int32, Int32, Int32, Array2D<Double>, Array2D<Double>, Int32)

Solves a system of linear equations A*X = B with a symmetric positive definite band matrix A using the Cholesky factorization A = UT*U or A = L*LT computed by DPBTRF.


(Overrides DecompositionOperations<TReal, TComplex>.BandCholeskySolve(MatrixTriangle, Int32, Int32, Int32, Array2D<TReal>, Array2D<TReal>, Int32))
BandLUDecompose(Int32, Int32, Int32, Int32, Array2D<Complex<Double>>, Array1D<Int32>, Int32)

Computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges.


(Overrides DecompositionOperations<TReal, TComplex>.BandLUDecompose(Int32, Int32, Int32, Int32, Array2D<TComplex>, Array1D<Int32>, Int32))
BandLUDecompose(Int32, Int32, Int32, Int32, Array2D<Double>, Array1D<Int32>, Int32)

Computes an LU factorization of a real m-by-n band matrix A using partial pivoting with row interchanges.


(Overrides DecompositionOperations<TReal, TComplex>.BandLUDecompose(Int32, Int32, Int32, Int32, Array2D<TReal>, Array1D<Int32>, Int32))
BandLUEstimateCondition(MatrixNorm, Int32, Int32, Int32, Array2D<Complex<Double>>, Array1D<Int32>, Double, Double, 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.


(Overrides DecompositionOperations<TReal, TComplex>.BandLUEstimateCondition(MatrixNorm, Int32, Int32, Int32, Array2D<TComplex>, Array1D<Int32>, TReal, TReal, Int32))
BandLUEstimateCondition(MatrixNorm, Int32, Int32, Int32, Array2D<Double>, Array1D<Int32>, Double, Double, 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.


(Overrides DecompositionOperations<TReal, TComplex>.BandLUEstimateCondition(MatrixNorm, Int32, Int32, Int32, Array2D<TReal>, Array1D<Int32>, TReal, TReal, Int32))
BandLUSolve(TransposeOperation, Int32, Int32, Int32, Int32, Array2D<Complex<Double>>, Array1D<Int32>, Array2D<Complex<Double>>, Int32)

Solves a system of linear equations A * X = B, AT * X = B, or AH * X = B with a general band matrix A using the LU factorization computed by ZGBTRF.


(Overrides DecompositionOperations<TReal, TComplex>.BandLUSolve(TransposeOperation, Int32, Int32, Int32, Int32, Array2D<TComplex>, Array1D<Int32>, Array2D<TComplex>, Int32))
BandLUSolve(TransposeOperation, Int32, Int32, Int32, Int32, Array2D<Double>, Array1D<Int32>, Array2D<Double>, Int32)

Solves a system of linear equations A * X = B or AT * X = B with a general band matrix A using the LU factorization computed by DGBTRF.


(Overrides DecompositionOperations<TReal, TComplex>.BandLUSolve(TransposeOperation, Int32, Int32, Int32, Int32, Array2D<TReal>, Array1D<Int32>, Array2D<TReal>, Int32))
BandTriangularSolve

Solves a triangular system of the form A * X = B or AT * X = B, where A is a triangular band matrix of order N, and B is an N-by NRHS matrix.


(Overrides DecompositionOperations<TReal, TComplex>.BandTriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Int32, Array2D<TReal>, Array2D<TReal>, Int32))
CholeskyDecompose(MatrixTriangle, Int32, Array2D<Complex<Double>>, Int32) Factors a symmetric positive definite matrix.
(Overrides DecompositionOperations<TReal, TComplex>.CholeskyDecompose(MatrixTriangle, Int32, Array2D<TComplex>, Int32))
CholeskyDecompose(MatrixTriangle, Int32, Array2D<Double>, Int32)

Computes the Cholesky factorization of a real symmetric positive definite matrix A.


(Overrides DecompositionOperations<TReal, TComplex>.CholeskyDecompose(MatrixTriangle, Int32, Array2D<TReal>, Int32))
CholeskyEstimateCondition(MatrixTriangle, Int32, Array2D<Complex<Double>>, Double, Double, Int32) Estimates the reciprocal of the condition number of a factored hermitian matrix.
(Overrides DecompositionOperations<TReal, TComplex>.CholeskyEstimateCondition(MatrixTriangle, Int32, Array2D<TComplex>, TReal, TReal, Int32))
CholeskyEstimateCondition(MatrixTriangle, Int32, Array2D<Double>, Double, Double, Int32)

Estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite matrix using the Cholesky factorization A = UT*U or A = L*LT computed by DPOTRF.


(Overrides DecompositionOperations<TReal, TComplex>.CholeskyEstimateCondition(MatrixTriangle, Int32, Array2D<TReal>, TReal, TReal, Int32))
CholeskyInvert(MatrixTriangle, Int32, Array2D<Complex<Double>>, Int32) Computes the inverse of a factored hermitian matrix.
(Overrides DecompositionOperations<TReal, TComplex>.CholeskyInvert(MatrixTriangle, Int32, Array2D<TComplex>, Int32))
CholeskyInvert(MatrixTriangle, Int32, Array2D<Double>, Int32)

Computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = UT*U or A = L*LT computed by DPOTRF.


(Overrides DecompositionOperations<TReal, TComplex>.CholeskyInvert(MatrixTriangle, Int32, Array2D<TReal>, Int32))
CholeskySolve(MatrixTriangle, Int32, Int32, Array2D<Complex<Double>>, Array2D<Complex<Double>>, Int32) Solves a hermitian system of equations.
(Overrides DecompositionOperations<TReal, TComplex>.CholeskySolve(MatrixTriangle, Int32, Int32, Array2D<TComplex>, Array2D<TComplex>, Int32))
CholeskySolve(MatrixTriangle, Int32, Int32, Array2D<Double>, Array2D<Double>, Int32)

Solves a system of linear equations A*X = B with a symmetric positive definite matrix A using the Cholesky factorization A = UT*U or A = L*LT computed by DPOTRF.


(Overrides DecompositionOperations<TReal, TComplex>.CholeskySolve(MatrixTriangle, Int32, Int32, Array2D<TReal>, Array2D<TReal>, Int32))
EigenvalueDecompose(Char, Char, Int32, Array2D<Complex<Double>>, Array1D<Complex<Double>>, Array2D<Complex<Double>>, Array2D<Complex<Double>>, Int32)

Computes for an N-by-N complex non-symmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors.


(Overrides DecompositionOperations<TReal, TComplex>.EigenvalueDecompose(Char, Char, Int32, Array2D<TComplex>, Array1D<TComplex>, Array2D<TComplex>, Array2D<TComplex>, Int32))
EigenvalueDecompose(Char, Char, Int32, Array2D<Double>, Array1D<Double>, Array1D<Double>, Array2D<Double>, Array2D<Double>, Int32)

Computes for an N-by-N real non-symmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors.


(Overrides DecompositionOperations<TReal, TComplex>.EigenvalueDecompose(Char, Char, Int32, Array2D<TReal>, Array1D<TReal>, Array1D<TReal>, Array2D<TReal>, Array2D<TReal>, Int32))
Encode(MatrixDiagonal) Converts a MatrixDiagonal value to the BLAS/LAPACK equivalent.
Encode(MatrixNorm) Converts a MatrixNorm value to the BLAS/LAPACK equivalent.
Encode(MatrixOperationSide) Converts a MatrixOperationSide value to the BLAS/LAPACK equivalent.
Encode(MatrixTriangle) Converts a MatrixTriangle value to the BLAS/LAPACK equivalent.
Encode(TransposeOperation) Converts a TransposeOperation value to the BLAS/LAPACK equivalent.
EqualsDetermines whether the specified object is equal to the current object.
(Inherited from Object)
GeneralizedEigenvalueDecompose(Char, Char, Int32, Array2D<Complex<Double>>, Array2D<Complex<Double>>, Array1D<Complex<Double>>, Array1D<Complex<Double>>, Array2D<Complex<Double>>, Array2D<Complex<Double>>, 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.


(Overrides DecompositionOperations<TReal, TComplex>.GeneralizedEigenvalueDecompose(Char, Char, Int32, Array2D<TComplex>, Array2D<TComplex>, Array1D<TComplex>, Array1D<TComplex>, Array2D<TComplex>, Array2D<TComplex>, Int32))
GeneralizedEigenvalueDecompose(Char, Char, Int32, Array2D<Double>, Array2D<Double>, Array1D<Double>, Array1D<Double>, Array1D<Double>, Array2D<Double>, Array2D<Double>, 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.


(Overrides DecompositionOperations<TReal, TComplex>.GeneralizedEigenvalueDecompose(Char, Char, Int32, Array2D<TReal>, Array2D<TReal>, Array1D<TReal>, Array1D<TReal>, Array1D<TReal>, Array2D<TReal>, Array2D<TReal>, Int32))
GeneralizedSingularValueDecompose(Char, Char, Char, Int32, Int32, Int32, Int32, Int32, Array2D<Complex<Double>>, Array2D<Complex<Double>>, Array1D<Double>, Array1D<Double>, Array2D<Complex<Double>>, Array2D<Complex<Double>>, Array2D<Complex<Double>>, 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**H*A*Q = D1*( 0 R ), V**H*B*Q = D2*( 0 R ) where U, V and Q are unitary matrices.


(Overrides DecompositionOperations<TReal, TComplex>.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))
GeneralizedSingularValueDecompose(Char, Char, Char, Int32, Int32, Int32, Int32, Int32, Array2D<Double>, Array2D<Double>, Array1D<Double>, Array1D<Double>, Array2D<Double>, Array2D<Double>, Array2D<Double>, 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**T*A*Q = D1*( 0 R ), V**T*B*Q = D2*( 0 R ) where U, V and Q are orthogonal matrices.


(Overrides DecompositionOperations<TReal, TComplex>.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))
GetHashCodeServes as the default hash function.
(Inherited from Object)
GetTypeGets the Type of the current instance.
(Inherited from Object)
HermitianDecompose

Computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method.


(Overrides DecompositionOperations<TReal, TComplex>.HermitianDecompose(MatrixTriangle, Int32, Array2D<TComplex>, Array1D<Int32>, Int32))
HermitianEigenvalueDecompose

Computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.


(Overrides DecompositionOperations<TReal, TComplex>.HermitianEigenvalueDecompose(Char, MatrixTriangle, Int32, Array2D<TComplex>, Array1D<TReal>, Int32))
HermitianEstimateCondition

Estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = U*D*UH or A = L*D*LH computed by ZHETRF.


(Overrides DecompositionOperations<TReal, TComplex>.HermitianEstimateCondition(MatrixTriangle, Int32, Array2D<TComplex>, Array1D<Int32>, TReal, TReal, Int32))
HermitianGeneralizedEigenvalueDecompose

Computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x.


(Overrides DecompositionOperations<TReal, TComplex>.HermitianGeneralizedEigenvalueDecompose(Int32, Char, MatrixTriangle, Int32, Array2D<TComplex>, Array2D<TComplex>, Array1D<TReal>, Int32))
HermitianInvert

Computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = U*D*UH or A = L*D*LH computed by ZHETRF.


(Overrides DecompositionOperations<TReal, TComplex>.HermitianInvert(MatrixTriangle, Int32, Array2D<TComplex>, Array1D<Int32>, Int32))
HermitianSolve

Solves a system of linear equations A*X = B with a complex Hermitian matrix A using the factorization A = U*D*UH or A = L*D*LH computed by ZHETRF.


(Overrides DecompositionOperations<TReal, TComplex>.HermitianSolve(MatrixTriangle, Int32, Int32, Array2D<TComplex>, Array1D<Int32>, Array2D<TComplex>, Int32))
LQDecompose(Int32, Int32, Array2D<Complex<Double>>, Array1D<Complex<Double>>, Int32)

Computes an LQ factorization of a complex M-by-N matrix A: A = L * Q.


(Overrides DecompositionOperations<TReal, TComplex>.LQDecompose(Int32, Int32, Array2D<TComplex>, Array1D<TComplex>, Int32))
LQDecompose(Int32, Int32, Array2D<Double>, Array1D<Double>, Int32)

Computes an LQ factorization of a real M-by-N matrix A: A = L * Q.


(Overrides DecompositionOperations<TReal, TComplex>.LQDecompose(Int32, Int32, Array2D<TReal>, Array1D<TReal>, Int32))
LQOrthogonalMultiply

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) .


(Overrides DecompositionOperations<TReal, TComplex>.LQOrthogonalMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2D<TReal>, Array1D<TReal>, Array2D<TReal>, Int32))
LQUnitaryMultiply

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)**H .


(Overrides DecompositionOperations<TReal, TComplex>.LQUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2D<TComplex>, Array1D<TComplex>, Array2D<TComplex>, Int32))
LUDecompose(Int32, Int32, Array2D<Complex<Double>>, 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.


(Overrides DecompositionOperations<TReal, TComplex>.LUDecompose(Int32, Int32, Array2D<TComplex>, Array1D<Int32>, Int32))
LUDecompose(Int32, Int32, Array2D<Double>, Array1D<Int32>, Int32)

Computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.


(Overrides DecompositionOperations<TReal, TComplex>.LUDecompose(Int32, Int32, Array2D<TReal>, Array1D<Int32>, Int32))
LUEstimateCondition(MatrixNorm, Int32, Array2D<Complex<Double>>, Double, Double, 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) CHARACTER*1 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) ZOUBLE PRECISION array, dimension (LDA,N) The factors L and U from the decomposition A = P*L*U as computed by ZGETRF. LDA (input) INTEGER The leading dimension of the array A. LDA >= Max(1,N). ANORM (input) ZOUBLE 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) ZOUBLE PRECISION The reciprocal of the condition number of the matrix A, computed as RCOND = 1/(norm(A) * norm(inv(A))). WORK (workspace) ZOUBLE 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
(Overrides DecompositionOperations<TReal, TComplex>.LUEstimateCondition(MatrixNorm, Int32, Array2D<TComplex>, TReal, TReal, Int32))
LUEstimateCondition(MatrixNorm, Int32, Array2D<Double>, Double, Double, 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.


(Overrides DecompositionOperations<TReal, TComplex>.LUEstimateCondition(MatrixNorm, Int32, Array2D<TReal>, TReal, TReal, Int32))
LUInvert(Int32, Array2D<Complex<Double>>, 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) ZOUBLE PRECISION array, dimension (LDA,N) On entry, the factors L and U from the decomposition A = P*L*U 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) ZOUBLE 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 >= N*NB, 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.
(Overrides DecompositionOperations<TReal, TComplex>.LUInvert(Int32, Array2D<TComplex>, Array1D<Int32>, Int32))
LUInvert(Int32, Array2D<Double>, Array1D<Int32>, Int32)

Computes the inverse of a matrix using the LU factorization computed by DGETRF.


(Overrides DecompositionOperations<TReal, TComplex>.LUInvert(Int32, Array2D<TReal>, Array1D<Int32>, Int32))
LUSolve(TransposeOperation, Int32, Int32, Array2D<Complex<Double>>, Array1D<Int32>, Array2D<Complex<Double>>, 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) CHARACTER*1 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) ZOUBLE PRECISION array, dimension (LDA,N) The factors L and U from the decomposition A = P*L*U 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) ZOUBLE 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 =====================================================================
(Overrides DecompositionOperations<TReal, TComplex>.LUSolve(TransposeOperation, Int32, Int32, Array2D<TComplex>, Array1D<Int32>, Array2D<TComplex>, Int32))
LUSolve(TransposeOperation, Int32, Int32, Array2D<Double>, Array1D<Int32>, Array2D<Double>, Int32)

Solves a system of linear equations A * X = B or AT * X = B with a general N-by-N matrix A using the LU factorization computed by DGETRF.


(Overrides DecompositionOperations<TReal, TComplex>.LUSolve(TransposeOperation, Int32, Int32, Array2D<TReal>, Array1D<Int32>, Array2D<TReal>, Int32))
QLDecompose(Int32, Int32, Array2D<Complex<Double>>, Array1D<Complex<Double>>, Int32)

Computes a QL factorization of a complex M-by-N matrix A: A = Q * L.


(Overrides DecompositionOperations<TReal, TComplex>.QLDecompose(Int32, Int32, Array2D<TComplex>, Array1D<TComplex>, Int32))
QLDecompose(Int32, Int32, Array2D<Double>, Array1D<Double>, Int32)

Computes a QL factorization of a real M-by-N matrix A: A = Q * L.


(Overrides DecompositionOperations<TReal, TComplex>.QLDecompose(Int32, Int32, Array2D<TReal>, Array1D<TReal>, Int32))
QLOrthogonalMultiply

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) .


(Overrides DecompositionOperations<TReal, TComplex>.QLOrthogonalMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2D<TReal>, Array1D<TReal>, Array2D<TReal>, Int32))
QLUnitaryMultiply

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) .


(Overrides DecompositionOperations<TReal, TComplex>.QLUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2D<TComplex>, Array1D<TComplex>, Array2D<TComplex>, Int32))
QRDecompose(Int32, Int32, Array2D<Complex<Double>>, Array1D<Complex<Double>>, 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) ZOUBLE 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) ZOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Zetails). WORK (workspace/output) ZOUBLE 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 >= N*NB, 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).
(Overrides DecompositionOperations<TReal, TComplex>.QRDecompose(Int32, Int32, Array2D<TComplex>, Array1D<TComplex>, Int32))
QRDecompose(Int32, Int32, Array2D<Double>, Array1D<Double>, Int32)

Computes a QR factorization of a real M-by-N matrix A: A = Q * R.


(Overrides DecompositionOperations<TReal, TComplex>.QRDecompose(Int32, Int32, Array2D<TReal>, Array1D<TReal>, Int32))
QRDecompose(Int32, Int32, Array2D<Double>, Array1D<Int32>, Array1D<Double>, Int32)

Computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.


(Overrides DecompositionOperations<TReal, TComplex>.QRDecompose(Int32, Int32, Array2D<TReal>, Array1D<Int32>, Array1D<TReal>, Int32))
QROrthogonalMultiply

Overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) .


(Overrides DecompositionOperations<TReal, TComplex>.QROrthogonalMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2D<TReal>, Array1D<TReal>, Array2D<TReal>, Int32))
QRUnitaryMultiply

Overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) .


(Overrides DecompositionOperations<TReal, TComplex>.QRUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2D<TComplex>, Array1D<TComplex>, Array2D<TComplex>, Int32))
ReportError

Is an error handler for the LAPACK routines.

RQDecompose(Int32, Int32, Array2D<Complex<Double>>, Array1D<Complex<Double>>, Int32)

Computes an RQ factorization of a complex M-by-N matrix A: A = R * Q.


(Overrides DecompositionOperations<TReal, TComplex>.RQDecompose(Int32, Int32, Array2D<TComplex>, Array1D<TComplex>, Int32))
RQDecompose(Int32, Int32, Array2D<Double>, Array1D<Double>, Int32)

Computes an RQ factorization of a real M-by-N matrix A: A = R * Q.


(Overrides DecompositionOperations<TReal, TComplex>.RQDecompose(Int32, Int32, Array2D<TReal>, Array1D<TReal>, Int32))
RQOrthogonalMultiply

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) .


(Overrides DecompositionOperations<TReal, TComplex>.RQOrthogonalMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2D<TReal>, Array1D<TReal>, Array2D<TReal>, Int32))
RQUnitaryMultiply

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 H(2)**H .


(Overrides DecompositionOperations<TReal, TComplex>.RQUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2D<TComplex>, Array1D<TComplex>, Array2D<TComplex>, Int32))
SingularValueDecompose(Char, Int32, Int32, Array2D<Complex<Double>>, Array1D<Double>, Array2D<Complex<Double>>, Array2D<Complex<Double>>, 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.


(Overrides DecompositionOperations<TReal, TComplex>.SingularValueDecompose(Char, Int32, Int32, Array2D<TComplex>, Array1D<TReal>, Array2D<TComplex>, Array2D<TComplex>, Int32))
SingularValueDecompose(Char, Int32, Int32, Array2D<Double>, Array1D<Double>, Array2D<Double>, Array2D<Double>, Int32)

Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and right singular vectors.


(Overrides DecompositionOperations<TReal, TComplex>.SingularValueDecompose(Char, Int32, Int32, Array2D<TReal>, Array1D<TReal>, Array2D<TReal>, Array2D<TReal>, Int32))
SymmetricDecompose

Computes the factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method.


(Overrides DecompositionOperations<TReal, TComplex>.SymmetricDecompose(MatrixTriangle, Int32, Array2D<TReal>, Array1D<Int32>, Int32))
SymmetricEigenvalueDecompose

Computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.


(Overrides DecompositionOperations<TReal, TComplex>.SymmetricEigenvalueDecompose(Char, MatrixTriangle, Int32, Array2D<TReal>, Array1D<TReal>, Int32))
SymmetricEstimateCondition

Estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric matrix A using the factorization A = U*D*UT or A = L*D*LT computed by DSYTRF.


(Overrides DecompositionOperations<TReal, TComplex>.SymmetricEstimateCondition(MatrixTriangle, Int32, Array2D<TReal>, Array1D<Int32>, TReal, TReal, Int32))
SymmetricGeneralizedEigenvalueDecompose

Computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x.


(Overrides DecompositionOperations<TReal, TComplex>.SymmetricGeneralizedEigenvalueDecompose(Int32, Char, MatrixTriangle, Int32, Array2D<TReal>, Array2D<TReal>, Array1D<TReal>, Int32))
SymmetricInvert

Computes the inverse of a real symmetric indefinite matrix A using the factorization A = U*D*UT or A = L*D*LT computed by DSYTRF.


(Overrides DecompositionOperations<TReal, TComplex>.SymmetricInvert(MatrixTriangle, Int32, Array2D<TReal>, Array1D<Int32>, Int32))
SymmetricSolve

Solves a system of linear equations A*X = B with a real symmetric matrix A using the factorization A = U*D*UT or A = L*D*LT computed by DSYTRF.


(Overrides DecompositionOperations<TReal, TComplex>.SymmetricSolve(MatrixTriangle, Int32, Int32, Array2D<TReal>, Array1D<Int32>, Array2D<TReal>, Int32))
ToStringReturns a string that represents the current object.
(Inherited from Object)
TriangularEstimateCondition(MatrixNorm, MatrixTriangle, MatrixDiagonal, Int32, Array2D<Complex<Double>>, Double, Int32) Approximates the reciprocal of the condition number of a complex triangular matrix.
(Overrides DecompositionOperations<TReal, TComplex>.TriangularEstimateCondition(MatrixNorm, MatrixTriangle, MatrixDiagonal, Int32, Array2D<TComplex>, TReal, Int32))
TriangularEstimateCondition(MatrixNorm, MatrixTriangle, MatrixDiagonal, Int32, Array2D<Double>, Double, Int32)

Estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm.


(Overrides DecompositionOperations<TReal, TComplex>.TriangularEstimateCondition(MatrixNorm, MatrixTriangle, MatrixDiagonal, Int32, Array2D<TReal>, TReal, Int32))
TriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Array2D<Complex<Double>>, Int32) Computes the inverse of a complex triangular matrix.
(Overrides DecompositionOperations<TReal, TComplex>.TriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Array2D<TComplex>, Int32))
TriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Array2D<Double>, Int32)

Computes the inverse of a real upper or lower triangular matrix A.


(Overrides DecompositionOperations<TReal, TComplex>.TriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Array2D<TReal>, Int32))
TriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Array2D<Complex<Double>>, Array2D<Complex<Double>>, Int32) Solves a complex triangular system of equations.
(Overrides DecompositionOperations<TReal, TComplex>.TriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Array2D<TComplex>, Array2D<TComplex>, Int32))
TriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Array2D<Double>, Array2D<Double>, Int32)

Solves a triangular system of the form A * X = B or AT * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix.


(Overrides DecompositionOperations<TReal, TComplex>.TriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Array2D<TReal>, Array2D<TReal>, Int32))

See Also