#include "slu_zdefs.h"
Functions | |
| void | zusolve (int, int, doublecomplex *, doublecomplex *) |
| Solves a dense upper triangular system. | |
| void | zlsolve (int, int, doublecomplex *, doublecomplex *) |
| Solves a dense UNIT lower triangular system. | |
| void | zmatvec (int, int, int, doublecomplex *, doublecomplex *, doublecomplex *) |
| Performs a dense matrix-vector multiply: Mxvec = Mxvec + M * vec. | |
| int | sp_ztrsv (char *uplo, char *trans, char *diag, SuperMatrix *L, SuperMatrix *U, doublecomplex *x, SuperLUStat_t *stat, int *info) |
| Solves one of the systems of equations A*x = b, or A'*x = b. | |
| int | sp_zgemv (char *trans, doublecomplex alpha, SuperMatrix *A, doublecomplex *x, int incx, doublecomplex beta, doublecomplex *y, int incy) |
| Performs one of the matrix-vector operations y := alpha*A*x + beta*y, or y := alpha*A'*x + beta*y. | |
-- SuperLU routine (version 3.0) -- Univ. of California Berkeley, Xerox Palo Alto Research Center, and Lawrence Berkeley National Lab. October 15, 2003
| int sp_zgemv | ( | char * | trans, | |
| doublecomplex | alpha, | |||
| SuperMatrix * | A, | |||
| doublecomplex * | x, | |||
| int | incx, | |||
| doublecomplex | beta, | |||
| doublecomplex * | y, | |||
| int | incy | |||
| ) |
Purpose =======
sp_zgemv() performs one of the matrix-vector operations y := alpha*A*x + beta*y, or y := alpha*A'*x + beta*y, where alpha and beta are scalars, x and y are vectors and A is a sparse A->nrow by A->ncol matrix.
Parameters ==========
TRANS - (input) char*
On entry, TRANS specifies the operation to be performed as
follows:
TRANS = 'N' or 'n' y := alpha*A*x + beta*y.
TRANS = 'T' or 't' y := alpha*A'*x + beta*y.
TRANS = 'C' or 'c' y := alpha*A'*x + beta*y.
ALPHA - (input) doublecomplex On entry, ALPHA specifies the scalar alpha.
A - (input) SuperMatrix*
Before entry, the leading m by n part of the array A must
contain the matrix of coefficients.
X - (input) doublecomplex*, array of DIMENSION at least
( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'
and at least
( 1 + ( m - 1 )*abs( INCX ) ) otherwise.
Before entry, the incremented array X must contain the
vector x.
INCX - (input) int
On entry, INCX specifies the increment for the elements of
X. INCX must not be zero.
BETA - (input) doublecomplex On entry, BETA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input.
Y - (output) doublecomplex*, array of DIMENSION at least
( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'
and at least
( 1 + ( n - 1 )*abs( INCY ) ) otherwise.
Before entry with BETA non-zero, the incremented array Y
must contain the vector y. On exit, Y is overwritten by the
updated vector y.
INCY - (input) int
On entry, INCY specifies the increment for the elements of
Y. INCY must not be zero.
==== Sparse Level 2 Blas routine.
| int sp_ztrsv | ( | char * | uplo, | |
| char * | trans, | |||
| char * | diag, | |||
| SuperMatrix * | L, | |||
| SuperMatrix * | U, | |||
| doublecomplex * | x, | |||
| SuperLUStat_t * | stat, | |||
| int * | info | |||
| ) |
Purpose =======
sp_ztrsv() solves one of the systems of equations A*x = b, or A'*x = b, where b and x are n element vectors and A is a sparse unit , or non-unit, upper or lower triangular matrix. No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine.
Parameters ==========
uplo - (input) char*
On entry, uplo specifies whether the matrix is an upper or
lower triangular matrix as follows:
uplo = 'U' or 'u' A is an upper triangular matrix.
uplo = 'L' or 'l' A is a lower triangular matrix.
trans - (input) char*
On entry, trans specifies the equations to be solved as
follows:
trans = 'N' or 'n' A*x = b.
trans = 'T' or 't' A'*x = b.
trans = 'C' or 'c' A^H*x = b.
diag - (input) char*
On entry, diag specifies whether or not A is unit
triangular as follows:
diag = 'U' or 'u' A is assumed to be unit triangular.
diag = 'N' or 'n' A is not assumed to be unit
triangular.
L - (input) SuperMatrix*
The factor L from the factorization Pr*A*Pc=L*U. Use
compressed row subscripts storage for supernodes,
i.e., L has types: Stype = SC, Dtype = SLU_Z, Mtype = TRLU.
U - (input) SuperMatrix* The factor U from the factorization Pr*A*Pc=L*U. U has types: Stype = NC, Dtype = SLU_Z, Mtype = TRU.
x - (input/output) doublecomplex*
Before entry, the incremented array X must contain the n
element right-hand side vector b. On exit, X is overwritten
with the solution vector x.
info - (output) int*
If *info = -i, the i-th argument had an illegal value.
| void zlsolve | ( | int | ldm, | |
| int | ncol, | |||
| doublecomplex * | M, | |||
| doublecomplex * | rhs | |||
| ) |
The unit lower triangular matrix is stored in a 2D array M(1:nrow,1:ncol). The solution will be returned in the rhs vector.
| void zmatvec | ( | int | ldm, | |
| int | nrow, | |||
| int | ncol, | |||
| doublecomplex * | M, | |||
| doublecomplex * | vec, | |||
| doublecomplex * | Mxvec | |||
| ) |
The input matrix is M(1:nrow,1:ncol); The product is returned in Mxvec[].
| void zusolve | ( | int | ldm, | |
| int | ncol, | |||
| doublecomplex * | M, | |||
| doublecomplex * | rhs | |||
| ) |
The upper triangular matrix is stored in a 2-dim array M(1:ldm,1:ncol). The solution will be returned in the rhs vector.
1.5.5