SuperLU: SRC/zsp_blas2.c File Reference

SuperLU 5.2.0

- Main Page
- Data Structures
- Files

- File List
- Globals

Functions
zsp_blas2.c File Reference

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

`#include "slu_zdefs.h"`
Include dependency graph for zsp_blas2.c:

## Functions
void | zusolve (int, int, doublecomplex *, doublecomplex *)
| Solves a dense upper triangular system. More...
void | zlsolve (int, int, doublecomplex *, doublecomplex *)
| Solves a dense UNIT lower triangular system. More...
void | zmatvec (int, int, int, doublecomplex *, doublecomplex *, doublecomplex *)
| Performs a dense matrix-vector multiply: Mxvec = Mxvec + M * vec. More...
int | sp_ztrsv (char *uplo, char *trans, char *diag, SuperMatrix *L, SuperMatrix *U, doublecomplex *x, SuperLUStat_t *stat, int *info)
| Solves one of the systems of equations A*x = b, or A'*x = b. More...
int | sp_zgemv (char *trans, doublecomplex alpha, SuperMatrix *A, doublecomplex *x, int incx, doublecomplex beta, doublecomplex *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

int sp_zgemv | ( | char * | trans,
|  | doublecomplex | alpha,
|  | SuperMatrix * | A,
|  | doublecomplex * | x,
|  | int | incx,
|  | doublecomplex | beta,
|  | doublecomplex * | y,
|  | int | incy
| ) |  |

#

    Purpose

      sp_zgemv()  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^H*x + beta*y.

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

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

#

    Purpose

      sp_ztrsv() 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_Z, Mtype = TRLU.

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

      x       - (input/output) doublecomplex*
                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 zlsolve | ( | int | ldm,
|  | int | ncol,
|  | doublecomplex * | M,
|  | doublecomplex * | 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 zmatvec | ( | int | ldm,
|  | int | nrow,
|  | int | ncol,
|  | doublecomplex * | M,
|  | doublecomplex * | vec,
|  | doublecomplex * | Mxvec
| ) |  |

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

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

Here is the call graph for this function: