|
| Name | Description |
|---|
 | BandCholeskyDecompose(MatrixTriangle, Int32, Int32, Array2DComplexDouble, Int32) |
Computes the Cholesky factorization of a complex Hermitian
positive definite band matrix A. |
| BandCholeskyDecompose(MatrixTriangle, Int32, Int32, Array2DDouble, Int32) |
Computes the Cholesky factorization of a real symmetric
positive definite band matrix A. |
| BandCholeskyDecompose(MatrixTriangle, Int32, Int32, Array2DDoubleComplex, Int32) |
Computes the Cholesky factorization of a complex Hermitian
positive definite band matrix A. |
| BandCholeskyEstimateCondition(MatrixTriangle, Int32, Int32, Array2DComplexDouble, 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. |
| BandCholeskyEstimateCondition(MatrixTriangle, Int32, Int32, Array2DDouble, 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. |
| BandCholeskyEstimateCondition(MatrixTriangle, Int32, Int32, Array2DDoubleComplex, 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. |
| BandCholeskySolve(MatrixTriangle, Int32, Int32, Int32, Array2DComplexDouble, Array2DComplexDouble, 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. |
| BandCholeskySolve(MatrixTriangle, Int32, Int32, Int32, Array2DDouble, Array2DDouble, 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. |
| BandCholeskySolve(MatrixTriangle, Int32, Int32, Int32, Array2DDoubleComplex, Array2DDoubleComplex, 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. |
| BandLUDecompose(Int32, Int32, Int32, Int32, Array2DComplexDouble, Array1DInt32, 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, Array2DDouble, Array1DInt32, 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, Array2DDoubleComplex, Array1DInt32, 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, Array2DComplexDouble, Array1DInt32, 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. |
| BandLUEstimateCondition(MatrixNorm, Int32, Int32, Int32, Array2DDouble, Array1DInt32, 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. |
| BandLUEstimateCondition(MatrixNorm, Int32, Int32, Int32, Array2DDoubleComplex, Array1DInt32, 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. |
| BandLUSolve(TransposeOperation, Int32, Int32, Int32, Int32, Array2DComplexDouble, Array1DInt32, Array2DComplexDouble, 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. |
| BandLUSolve(TransposeOperation, Int32, Int32, Int32, Int32, Array2DDouble, Array1DInt32, Array2DDouble, 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. |
| BandLUSolve(TransposeOperation, Int32, Int32, Int32, Int32, Array2DDoubleComplex, Array1DInt32, Array2DDoubleComplex, 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. |
| 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. |
| CholeskyDecompose(MatrixTriangle, Int32, Array2DComplexDouble, Int32) |
Factors a symmetric positive definite matrix.
(Overrides DecompositionOperationsTReal, TComplexCholeskyDecompose(MatrixTriangle, Int32, Array2DTComplex, Int32).) |
| CholeskyDecompose(MatrixTriangle, Int32, Array2DDouble, Int32) |
Computes the Cholesky factorization of a real symmetric
positive definite matrix A. |
| CholeskyDecompose(MatrixTriangle, Int32, Array2DDoubleComplex, Int32) |
Factors a symmetric positive definite matrix.
(Overrides DecompositionOperationsTReal, TComplexCholeskyDecompose(MatrixTriangle, Int32, Array2DTComplex, Int32).) |
| CholeskyEstimateCondition(MatrixTriangle, Int32, Array2DComplexDouble, Double, Double, Int32) |
Estimates the reciprocal of the condition number of a factored hermitian matrix.
(Overrides DecompositionOperationsTReal, TComplexCholeskyEstimateCondition(MatrixTriangle, Int32, Array2DTComplex, TReal, TReal, Int32).) |
| CholeskyEstimateCondition(MatrixTriangle, Int32, Array2DDouble, 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. |
| CholeskyEstimateCondition(MatrixTriangle, Int32, Array2DDoubleComplex, Double, Double, Int32) |
Estimates the reciprocal of the condition number of a factored hermitian matrix.
(Overrides DecompositionOperationsTReal, TComplexCholeskyEstimateCondition(MatrixTriangle, Int32, Array2DTComplex, TReal, TReal, Int32).) |
| CholeskyInvert(MatrixTriangle, Int32, Array2DComplexDouble, Int32) |
Computes the inverse of a factored hermitian matrix.
(Overrides DecompositionOperationsTReal, TComplexCholeskyInvert(MatrixTriangle, Int32, Array2DTComplex, Int32).) |
| CholeskyInvert(MatrixTriangle, Int32, Array2DDouble, 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. |
| CholeskyInvert(MatrixTriangle, Int32, Array2DDoubleComplex, Int32) |
Computes the inverse of a factored hermitian matrix.
(Overrides DecompositionOperationsTReal, TComplexCholeskyInvert(MatrixTriangle, Int32, Array2DTComplex, Int32).) |
| CholeskySolve(MatrixTriangle, Int32, Int32, Array2DComplexDouble, Array2DComplexDouble, Int32) |
Solves a hermitian system of equations.
(Overrides DecompositionOperationsTReal, TComplexCholeskySolve(MatrixTriangle, Int32, Int32, Array2DTComplex, Array2DTComplex, Int32).) |
| CholeskySolve(MatrixTriangle, Int32, Int32, Array2DDouble, Array2DDouble, 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. |
| CholeskySolve(MatrixTriangle, Int32, Int32, Array2DDoubleComplex, Array2DDoubleComplex, Int32) |
Solves a hermitian system of equations.
(Overrides DecompositionOperationsTReal, TComplexCholeskySolve(MatrixTriangle, Int32, Int32, Array2DTComplex, Array2DTComplex, Int32).) |
| EigenvalueDecompose(Char, Char, Int32, Array2DComplexDouble, Array1DComplexDouble, Array2DComplexDouble, Array2DComplexDouble, 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, Array2DDoubleComplex, Array1DDoubleComplex, Array2DDoubleComplex, Array2DDoubleComplex, Int32) |
Computes for an N-by-N complex nonsymmetric matrix A, the
eigenvalues and, optionally, the left and/or right eigenvectors. |
| EigenvalueDecompose(Char, Char, Int32, Array2DDouble, Array1DDouble, Array1DDouble, Array2DDouble, Array2DDouble, 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. |
| GeneralizedEigenvalueDecompose(Char, Char, Int32, Array2DComplexDouble, Array2DComplexDouble, Array1DComplexDouble, Array1DComplexDouble, Array2DComplexDouble, Array2DComplexDouble, 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, Array2DDouble, Array2DDouble, Array1DDouble, Array1DDouble, Array1DDouble, Array2DDouble, Array2DDouble, 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. |
| GeneralizedSingularValueDecompose(Char, Char, Char, Int32, Int32, Int32, Int32, Int32, Array2DComplexDouble, Array2DComplexDouble, Array1DDouble, Array1DDouble, Array2DComplexDouble, Array2DComplexDouble, Array2DComplexDouble, Array1DInt32, Int32) | (Overrides DecompositionOperationsTReal, TComplexGeneralizedSingularValueDecompose(Char, Char, Char, Int32, Int32, Int32, Int32, Int32, Array2DTComplex, Array2DTComplex, Array1DTReal, Array1DTReal, Array2DTComplex, Array2DTComplex, Array2DTComplex, Array1DInt32, Int32).) |
| GeneralizedSingularValueDecompose(Char, Char, Char, Int32, Int32, Int32, Int32, Int32, Array2DDouble, Array2DDouble, Array1DDouble, Array1DDouble, Array2DDouble, Array2DDouble, Array2DDouble, Array1DInt32, Int32) | (Overrides DecompositionOperationsTReal, TComplexGeneralizedSingularValueDecompose(Char, Char, Char, Int32, Int32, Int32, Int32, Int32, Array2DTComplex, Array2DTComplex, Array1DTReal, Array1DTReal, Array2DTComplex, Array2DTComplex, Array2DTComplex, Array1DInt32, Int32).) |
| GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.) |
| GetType | Gets the Type of the current instance. |
| HermitianDecompose(MatrixTriangle, Int32, Array2DComplexDouble, Array1DInt32, Int32) |
Computes the factorization of a complex Hermitian matrix A
using the Bunch-Kaufman diagonal pivoting method. |
| HermitianDecompose(MatrixTriangle, Int32, Array2DDoubleComplex, Array1DInt32, Int32) |
Computes the factorization of a complex Hermitian matrix A
using the Bunch-Kaufman diagonal pivoting method. |
| HermitianEigenvalueDecompose(Char, MatrixTriangle, Int32, Array2DComplexDouble, Array1DDouble, Int32) |
Computes all eigenvalues and, optionally, eigenvectors of a
complex Hermitian matrix A. |
| HermitianEigenvalueDecompose(Char, MatrixTriangle, Int32, Array2DDoubleComplex, Array1DDouble, Int32) |
Computes all eigenvalues and, optionally, eigenvectors of a
complex Hermitian matrix A. |
| HermitianEstimateCondition(MatrixTriangle, Int32, Array2DComplexDouble, Array1DInt32, Double, Double, Int32) |
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. |
| HermitianEstimateCondition(MatrixTriangle, Int32, Array2DDoubleComplex, Array1DInt32, Double, Double, Int32) |
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. |
| HermitianGeneralizedEigenvalueDecompose |
Computes selected eigenvalues, and optionally, 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. |
| HermitianInvert(MatrixTriangle, Int32, Array2DComplexDouble, Array1DInt32, Int32) |
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. |
| HermitianInvert(MatrixTriangle, Int32, Array2DDoubleComplex, Array1DInt32, Int32) |
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. |
| HermitianSolve(MatrixTriangle, Int32, Int32, Array2DComplexDouble, Array1DInt32, Array2DComplexDouble, Int32) |
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. |
| HermitianSolve(MatrixTriangle, Int32, Int32, Array2DDoubleComplex, Array1DInt32, Array2DDoubleComplex, Int32) |
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. |
| LQDecompose(Int32, Int32, Array2DComplexDouble, Array1DComplexDouble, Int32) |
Computes an LQ factorization of a complex M-by-N matrix A:
A = L * Q. |
| LQDecompose(Int32, Int32, Array2DDouble, Array1DDouble, Int32) |
Computes an LQ factorization of a complex M-by-N matrix A:
A = L * Q. |
| 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) . |
| 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 . |
| LUDecompose(Int32, Int32, Array2DComplexDouble, Array1DInt32, 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, Array2DDouble, Array1DInt32, Int32) |
Computes an LU factorization of a general M-by-N matrix A
using partial pivoting with row interchanges. |
| LUDecompose(Int32, Int32, Array2DDoubleComplex, Array1DInt32, 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, Array2DComplexDouble, 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 DecompositionOperationsTReal, TComplexLUEstimateCondition(MatrixNorm, Int32, Array2DTComplex, TReal, TReal, Int32).) |
| LUEstimateCondition(MatrixNorm, Int32, Array2DDouble, 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. |
| LUEstimateCondition(MatrixNorm, Int32, Array2DDoubleComplex, 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 DecompositionOperationsTReal, TComplexLUEstimateCondition(MatrixNorm, Int32, Array2DTComplex, TReal, TReal, Int32).) |
| LUInvert(Int32, Array2DComplexDouble, Array1DInt32, 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 DecompositionOperationsTReal, TComplexLUInvert(Int32, Array2DTComplex, Array1DInt32, Int32).) |
| LUInvert(Int32, Array2DDouble, Array1DInt32, Int32) |
Computes the inverse of a matrix using the LU factorization
computed by DGETRF. |
| LUInvert(Int32, Array2DDoubleComplex, Array1DInt32, 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 DecompositionOperationsTReal, TComplexLUInvert(Int32, Array2DTComplex, Array1DInt32, Int32).) |
| LUSolve(TransposeOperation, Int32, Int32, Array2DComplexDouble, Array1DInt32, Array2DComplexDouble, 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 DecompositionOperationsTReal, TComplexLUSolve(TransposeOperation, Int32, Int32, Array2DTComplex, Array1DInt32, Array2DTComplex, Int32).) |
| LUSolve(TransposeOperation, Int32, Int32, Array2DDouble, Array1DInt32, Array2DDouble, 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. |
| LUSolve(TransposeOperation, Int32, Int32, Array2DDoubleComplex, Array1DInt32, Array2DDoubleComplex, 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 DecompositionOperationsTReal, TComplexLUSolve(TransposeOperation, Int32, Int32, Array2DTComplex, Array1DInt32, Array2DTComplex, Int32).) |
| QLDecompose(Int32, Int32, Array2DComplexDouble, Array1DComplexDouble, Int32) |
Computes a QL factorization of a complex M-by-N matrix A:
A = Q * L. |
| QLDecompose(Int32, Int32, Array2DDouble, Array1DDouble, Int32) |
Computes a QL factorization of a complex M-by-N matrix A:
A = Q * L. |
| 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) . |
| 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) . |
| QRDecompose(Int32, Int32, Array2DComplexDouble, Array1DComplexDouble, 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 DecompositionOperationsTReal, TComplexQRDecompose(Int32, Int32, Array2DTComplex, Array1DTComplex, Int32).) |
| QRDecompose(Int32, Int32, Array2DDouble, Array1DDouble, Int32) |
Computes a QR factorization of a real M-by-N matrix A:
A = Q * R. |
| QRDecompose(Int32, Int32, Array2DDoubleComplex, Array1DDoubleComplex, 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 DecompositionOperationsTReal, TComplexQRDecompose(Int32, Int32, Array2DTComplex, Array1DTComplex, Int32).) |
| QRDecompose(Int32, Int32, Array2DDouble, Array1DInt32, Array1DDouble, Int32) |
Computes a QR factorization with column pivoting of a
matrix A: A*P = Q*R using Level 3 BLAS. |
| 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) . |
| QRUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2DComplexDouble, Array1DComplexDouble, Array2DComplexDouble, Int32) |
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) . |
| QRUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2DDoubleComplex, Array1DDoubleComplex, Array2DDoubleComplex, Int32) |
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) . |
| RQDecompose(Int32, Int32, Array2DComplexDouble, Array1DComplexDouble, Int32) |
Computes an RQ factorization of a complex M-by-N matrix A:
A = R * Q. |
| RQDecompose(Int32, Int32, Array2DDouble, Array1DDouble, Int32) |
Computes an RQ factorization of a complex M-by-N matrix A:
A = R * Q. |
| 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) . |
| 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 . |
| SingularValueDecompose(Char, Int32, Int32, Array2DComplexDouble, Array1DDouble, Array2DComplexDouble, Array2DComplexDouble, 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, Array2DDouble, Array1DDouble, Array2DDouble, Array2DDouble, 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, Array2DDoubleComplex, Array1DDouble, Array2DDoubleComplex, Array2DDoubleComplex, 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 |
Computes the factorization of a real symmetric matrix A using
the Bunch-Kaufman diagonal pivoting method. |
| SymmetricEigenvalueDecompose |
Computes all eigenvalues and, optionally, eigenvectors of a
real symmetric matrix A. |
| 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. |
| SymmetricGeneralizedEigenvalueDecompose |
Computes selected eigenvalues, and optionally, 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. |
| 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. |
| 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. |
| ToString | Returns a string that represents the current object. (Inherited from Object.) |
| TriangularEstimateCondition(MatrixNorm, MatrixTriangle, MatrixDiagonal, Int32, Array2DComplexDouble, Double, Int32) |
Approximates the reciprocal of the condition number of a complex triangular matrix.
(Overrides DecompositionOperationsTReal, TComplexTriangularEstimateCondition(MatrixNorm, MatrixTriangle, MatrixDiagonal, Int32, Array2DTComplex, TReal, Int32).) |
| TriangularEstimateCondition(MatrixNorm, MatrixTriangle, MatrixDiagonal, Int32, Array2DDouble, Double, 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, Array2DDoubleComplex, Double, Int32) |
Approximates the reciprocal of the condition number of a complex triangular matrix.
(Overrides DecompositionOperationsTReal, TComplexTriangularEstimateCondition(MatrixNorm, MatrixTriangle, MatrixDiagonal, Int32, Array2DTComplex, TReal, Int32).) |
| TriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Array2DComplexDouble, Int32) |
Computes the inverse of a complex triangular matrix.
(Overrides DecompositionOperationsTReal, TComplexTriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Array2DTComplex, Int32).) |
| TriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Array2DDouble, Int32) |
Computes the inverse of a real upper or lower triangular
matrix A. |
| TriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Array2DDoubleComplex, Int32) |
Computes the inverse of a complex triangular matrix.
(Overrides DecompositionOperationsTReal, TComplexTriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Array2DTComplex, Int32).) |
| TriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Array2DComplexDouble, Array2DComplexDouble, Int32) |
Solves a complex triangular system of equations.
(Overrides DecompositionOperationsTReal, TComplexTriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Array2DTComplex, Array2DTComplex, Int32).) |
| TriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Array2DDouble, Array2DDouble, 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. |
| TriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Array2DDoubleComplex, Array2DDoubleComplex, Int32) |
Solves a complex triangular system of equations.
(Overrides DecompositionOperationsTReal, TComplexTriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Array2DTComplex, Array2DTComplex, Int32).) |