SuperLU: SRC/ssp_blas2.c File Reference

# SRC/ssp_blas2.c File Reference

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

`#include "slu_sdefs.h"`

## Functions
void | susolve (int, int, float *, float *)
| Solves a dense upper triangular system.
void | slsolve (int, int, float *, float *)
| Solves a dense UNIT lower triangular system.
void | smatvec (int, int, int, float *, float *, float *)
| Performs a dense matrix-vector multiply: Mxvec = Mxvec + M * vec.
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.
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,.

## 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 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.

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.

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.