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

Copyright (c) 2003, The Regents of the University of California, through Lawrence Berkeley National Laboratory (subject to receipt of any required approvals from U.S. Dept. of Energy)

All rights reserved.

The source code is distributed under BSD license, see the file License.txt at the top-level directory.

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