lsd_mkb/lsd_mkb_superlu/superlu_seq/dsp_blas2.c File Reference

#include "slu_ddefs.h"

Include dependency graph for dsp_blas2.c:

Functions
void	dusolve (int, int, double *, double *)
	Solves a dense upper triangular system.
void	dlsolve (int, int, double *, double *)
	Solves a dense UNIT lower triangular system.
void	dmatvec (int, int, int, double *, double *, double *)
	Performs a dense matrix-vector multiply: Mxvec = Mxvec + M * vec.
int	sp_dtrsv (char *uplo, char *trans, char *diag, SuperMatrix *L, SuperMatrix *U, double *x, SuperLUStat_t *stat, int *info)
	Solves one of the systems of equations A*x = b, or A'*x = b.
int	sp_dgemv (char *trans, double alpha, SuperMatrix *A, double *x, int incx, double beta, double *y, int incy)
	Performs one of the matrix-vector operations y := alpha*A*x + beta*y, or y := alpha*A'*x + beta*y,.

---

Function Documentation

void dlsolve	(	int	ldm,
		int	ncol,
		double *	M,
		double *	rhs
	)

Solves a dense UNIT lower triangular system.

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 dmatvec	(	int	ldm,
		int	nrow,
		int	ncol,
		double *	M,
		double *	vec,
		double *	Mxvec
	)

Performs a dense matrix-vector multiply: Mxvec = Mxvec + M * vec.

The input matrix is M(1:nrow,1:ncol); The product is returned in Mxvec[].

void dusolve	(	int	ldm,
		int	ncol,
		double *	M,
		double *	rhs
	)

Solves a dense upper triangular system.

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.

int sp_dgemv	(	char *	trans,
		double	alpha,
		SuperMatrix *	A,
		double *	x,
		int	incx,
		double	beta,
		double *	y,
		int	incy
	)

Performs one of the matrix-vector operations y := alpha*A*x + beta*y, or y := alpha*A'*x + beta*y,.

   Purpose   
   =======

   sp_dgemv()  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) double
            On entry, ALPHA specifies the scalar alpha.

   A      - (input) SuperMatrix*
            Matrix A with a sparse format, of dimension (A->nrow, A->ncol).
            Currently, the type of A can be:
                Stype = NC or NCP; Dtype = SLU_D; Mtype = GE. 
            In the future, more general A can be handled.

   X      - (input) double*, 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) double
            On entry, BETA specifies the scalar beta. When BETA is   
            supplied as zero then Y need not be set on input.

   Y      - (output) double*,  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.   
 

Here is the call graph for this function:

Here is the caller graph for this function:

int sp_dtrsv	(	char *	uplo,
		char *	trans,
		char *	diag,
		SuperMatrix *	L,
		SuperMatrix *	U,
		double *	x,
		SuperLUStat_t *	stat,
		int *	info
	)

Solves one of the systems of equations A*x = b, or A'*x = b.

   Purpose
   =======

   sp_dtrsv() 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'*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_D, Mtype = TRLU.

   U       - (input) SuperMatrix*
	        The factor U from the factorization Pr*A*Pc=L*U.
	        U has types: Stype = NC, Dtype = SLU_D, Mtype = TRU.

   x       - (input/output) double*
             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.
 

Here is the call graph for this function:

Here is the caller graph for this function: