lsd_mkb/lsd_mkb_superlu/superlu_seq/dgstrs.c File Reference

#include "slu_ddefs.h"

Include dependency graph for dgstrs.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.
void	dgstrs (trans_t trans, SuperMatrix *L, SuperMatrix *U, int *perm_c, int *perm_r, SuperMatrix *B, SuperLUStat_t *stat, int *info)
void	dprint_soln (int n, int nrhs, double *soln)

---

Function Documentation

void dgstrs	(	trans_t	trans,
		SuperMatrix *	L,
		SuperMatrix *	U,
		int *	perm_c,
		int *	perm_r,
		SuperMatrix *	B,
		SuperLUStat_t *	stat,
		int *	info
	)

 Purpose
 =======

 DGSTRS solves a system of linear equations A*X=B or A'*X=B
 with A sparse and B dense, using the LU factorization computed by
 DGSTRF.

 See supermatrix.h for the definition of 'SuperMatrix' structure.

 Arguments
 =========

 trans   (input) trans_t
          Specifies the form of the system of equations:
          = NOTRANS: A * X = B  (No transpose)
          = TRANS:   A'* X = B  (Transpose)
          = CONJ:    A**H * X = B  (Conjugate transpose)

 L       (input) SuperMatrix*
         The factor L from the factorization Pr*A*Pc=L*U as computed by
         dgstrf(). Use compressed row subscripts storage for supernodes,
         i.e., L has types: Stype = SLU_SC, Dtype = SLU_D, Mtype = SLU_TRLU.

 U       (input) SuperMatrix*
         The factor U from the factorization Pr*A*Pc=L*U as computed by
         dgstrf(). Use column-wise storage scheme, i.e., U has types:
         Stype = SLU_NC, Dtype = SLU_D, Mtype = SLU_TRU.

 perm_c  (input) int*, dimension (L->ncol)
	   Column permutation vector, which defines the 
         permutation matrix Pc; perm_c[i] = j means column i of A is 
         in position j in A*Pc.

 perm_r  (input) int*, dimension (L->nrow)
         Row permutation vector, which defines the permutation matrix Pr; 
         perm_r[i] = j means row i of A is in position j in Pr*A.

 B       (input/output) SuperMatrix*
         B has types: Stype = SLU_DN, Dtype = SLU_D, Mtype = SLU_GE.
         On entry, the right hand side matrix.
         On exit, the solution matrix if info = 0;

 stat     (output) SuperLUStat_t*
          Record the statistics on runtime and floating-point operation count.
          See util.h for the definition of 'SuperLUStat_t'.

 info    (output) int*
 	   = 0: successful exit
	   < 0: 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:

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 dprint_soln	(	int	n,
		int	nrhs,
		double *	soln
	)

Here is the caller graph for this function:

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.