SuperLU  5.0
Functions
ssp_blas2.c File Reference

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

#include "slu_sdefs.h"
Include dependency graph for ssp_blas2.c:

Functions

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

Detailed Description

– SuperLU routine (version 5.1) –
Univ. of California Berkeley, Xerox Palo Alto Research Center,
and Lawrence Berkeley National Lab.
October 15, 2003
Last update: December 3, 2015

Function Documentation

void slsolve ( int  ldm,
int  ncol,
float *  M,
float *  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 smatvec ( int  ldm,
int  nrow,
int  ncol,
float *  M,
float *  vec,
float *  Mxvec 
)

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

int sp_sgemv ( char *  trans,
float  alpha,
SuperMatrix A,
float *  x,
int  incx,
float  beta,
float *  y,
int  incy 
)

Purpose

  sp_sgemv()  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) float
           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_S; Mtype = GE. 
           In the future, more general A can be handled.
  X      - (input) float*, 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) float
           On entry, BETA specifies the scalar beta. When BETA is   
           supplied as zero then Y need not be set on input.
  Y      - (output) float*,  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:

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

Purpose

  sp_strsv() 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_S, Mtype = TRLU.
  U       - (input) SuperMatrix*
             The factor U from the factorization Pr*A*Pc=L*U.
             U has types: Stype = NC, Dtype = SLU_S, Mtype = TRU.
  x       - (input/output) float*
            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:

void susolve ( int  ldm,
int  ncol,
float *  M,
float *  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.