Specifies the methods that must be implemented by a
class to support single-precision complex real LAPACK routines
for general matrices.
Extreme.Numerics.Version4x.Net40 (in Extreme.Numerics.Version4x.Net40.dll) Version: 4.2.11333.0 (5.0.12317.0)
|
| Name | Description |
|---|
 | Cgecon |
CGECON 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 CGETRF.
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) COUBLE PRECISION array, dimension (LDA,N)
The factors L and U from the decomposition A = P*L*U
as computed by CGETRF.
LDA (input) INTEGER
The leading dimension of the array A. LDA >= Max(1,N).
ANORM (input) COUBLE 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) COUBLE PRECISION
The reciprocal of the condition number of the matrix A,
computed as RCOND = 1/(norm(A) * norm(inv(A))).
WORK (workspace) COUBLE 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
|
| Cgeqrf |
CGEQRF 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) COUBLE 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
Cetails).
LDA (input) INTEGER
The leading dimension of the array A. LDA >= max(1,M).
TAU (output) COUBLE PRECISION array, dimension (min(M,N))
The scalar factors of the elementary reflectors (see Further
Cetails).
WORK (workspace/output) COUBLE 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 Cetails
===============
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).
|
| Cgesdd | |
| Cgetrf |
CGETRF 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.
|
| Cgetri |
CGETRI computes the inverse of a matrix using the LU decomposition
computed by CGETRF.
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) COUBLE PRECISION array, dimension (LDA,N)
On entry, the factors L and U from the decomposition
A = P*L*U as computed by CGETRF.
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 CGETRF; for 1< =i< =N, row i of the
matrix was interchanged with row IPIVi.
WORK (workspace/output) COUBLE 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.
|
| Cgetrs |
CGETRS 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 CGETRF.
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) COUBLE PRECISION array, dimension (LDA,N)
The factors L and U from the decomposition A = P*L*U
as computed by CGETRF.
LDA (input) INTEGER
The leading dimension of the array A. LDA >= Max(1,N).
IPIV (input) INTEGER array, dimension (N)
The pivot indexes from CGETRF; for 1< =i< =N, row i of the
matrix was interchanged with row IPIVi.
B (input/output) COUBLE 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
=====================================================================
|
| Clacpy |
Copies the specified elements of a complex matrix.
|
| Cpocon |
Estimates the reciprocal of the condition number of a factored hermitian matrix.
|
| Cpotrf |
Factors a symmetric positive definite matrix.
|
| Cpotri |
Computes the inverse of a factored hermitian matrix.
|
| Cpotrs |
Solves a hermitian system of equations.
|
| Ctrcon |
Approximates the reciprocal of the condition number of a complex triangular matrix.
|
| Ctrtri |
Computes the inverse of a complex triangular matrix.
|
| Ctrtrs |
Solves a complex triangular system of equations.
|
| Cunmqr | |
| Equals | Determines whether the specified Object is equal to the current 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.) |
| GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.) |
| GetType | Gets the Type of the current instance. |
| MemberwiseClone | Creates a shallow copy of the current Object. |
| ToString | Returns a string that represents the current object. (Inherited from Object.) |
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.