SRC/csp_blas2.c File Reference

Sparse BLAS 2, using some dense BLAS 2 operations. More...

#include "slu_cdefs.h"

Functions

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


Detailed Description

 -- SuperLU routine (version 3.0) --
 Univ. of California Berkeley, Xerox Palo Alto Research Center,
 and Lawrence Berkeley National Lab.
 October 15, 2003
 

Function Documentation

void clsolve int  ldm,
int  ncol,
complex M,
complex 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 cmatvec int  ldm,
int  nrow,
int  ncol,
complex M,
complex vec,
complex Mxvec
 

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

void cusolve int  ldm,
int  ncol,
complex M,
complex 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.

int sp_cgemv char *  trans,
complex  alpha,
SuperMatrix A,
complex x,
int  incx,
complex  beta,
complex y,
int  incy
 

  
   Purpose   
   =======

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

   Y      - (output) complex*,  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_ctrsv char *  uplo,
char *  trans,
char *  diag,
SuperMatrix L,
SuperMatrix U,
complex x,
SuperLUStat_t stat,
int *  info
 

   Purpose
   =======

   sp_ctrsv() 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_C, Mtype = TRLU.

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

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


Generated on Fri Aug 1 22:40:40 2008 for SuperLU by  doxygen 1.4.6