Go to main content
Oracle Developer Studio 12.5 Man Pages

Exit Print View

Updated: June 2017
 
 

zgssv (3p)

Name

zgssv - solves a system of linear equations A*X=B using the LU factorization from sgstrf.

Synopsis

#include <sunperf.h>


void sgssv(superlu_options_t *options, SuperMatrix *A, int *perm_c, int
*perm_r,  SuperMatrix *L, SuperMatrix *U, SuperMatrix *B, Super-
LUStat_t *stat, int *info)


void dgssv(superlu_options_t *options, SuperMatrix *A, int *perm_c, int
*perm_r,  SuperMatrix *L, SuperMatrix *U, SuperMatrix *B, Super-
LUStat_t *stat, int *info)


void cgssv(superlu_options_t *options, SuperMatrix *A, int *perm_c, int
*perm_r,  SuperMatrix *L, SuperMatrix *U, SuperMatrix *B, Super-
LUStat_t *stat, int *info)


void zgssv(superlu_options_t *options, SuperMatrix *A, int *perm_c, int
*perm_r,  SuperMatrix *L, SuperMatrix *U, SuperMatrix *B, Super-
LUStat_t *stat, int *info)


void sgssv_64(superlu_options_t_64 *options,  SuperMatrix_64  *A,  long
*perm_c,  long  *perm_r,  SuperMatrix_64  *L, SuperMatrix_64 *U,
SuperMatrix_64 *B, SuperLUStat_t_64 *stat, long *info)


void dgssv_64(superlu_options_t_64 *options,  SuperMatrix_64  *A,  long
*perm_c,  long  *perm_r,  SuperMatrix_64  *L, SuperMatrix_64 *U,
SuperMatrix_64 *B, SuperLUStat_t_64 *stat, long *info)


void cgssv_64(superlu_options_t_64 *options,  SuperMatrix_64  *A,  long
*perm_c,  long  *perm_r,  SuperMatrix_64  *L, SuperMatrix_64 *U,
SuperMatrix_64 *B, SuperLUStat_t_64 *stat, long *info)


void zgssv_64(superlu_options_t_64 *options,  SuperMatrix_64  *A,  long
*perm_c,  long  *perm_r,  SuperMatrix_64  *L, SuperMatrix_64 *U,
SuperMatrix_64 *B, SuperLUStat_t_64 *stat, long *info)

Description

Oracle Solaris Studio Performance Library                             gssv(3P)



NAME
       gssv:  cgssv, dgssv, sgssv, zgssv - solves a system of linear equations
       A*X=B using the LU factorization from sgstrf.


SYNOPSIS
       #include <sunperf.h>


       void sgssv(superlu_options_t *options, SuperMatrix *A, int *perm_c, int
              *perm_r,  SuperMatrix *L, SuperMatrix *U, SuperMatrix *B, Super-
              LUStat_t *stat, int *info)


       void dgssv(superlu_options_t *options, SuperMatrix *A, int *perm_c, int
              *perm_r,  SuperMatrix *L, SuperMatrix *U, SuperMatrix *B, Super-
              LUStat_t *stat, int *info)


       void cgssv(superlu_options_t *options, SuperMatrix *A, int *perm_c, int
              *perm_r,  SuperMatrix *L, SuperMatrix *U, SuperMatrix *B, Super-
              LUStat_t *stat, int *info)


       void zgssv(superlu_options_t *options, SuperMatrix *A, int *perm_c, int
              *perm_r,  SuperMatrix *L, SuperMatrix *U, SuperMatrix *B, Super-
              LUStat_t *stat, int *info)


       void sgssv_64(superlu_options_t_64 *options,  SuperMatrix_64  *A,  long
              *perm_c,  long  *perm_r,  SuperMatrix_64  *L, SuperMatrix_64 *U,
              SuperMatrix_64 *B, SuperLUStat_t_64 *stat, long *info)


       void dgssv_64(superlu_options_t_64 *options,  SuperMatrix_64  *A,  long
              *perm_c,  long  *perm_r,  SuperMatrix_64  *L, SuperMatrix_64 *U,
              SuperMatrix_64 *B, SuperLUStat_t_64 *stat, long *info)


       void cgssv_64(superlu_options_t_64 *options,  SuperMatrix_64  *A,  long
              *perm_c,  long  *perm_r,  SuperMatrix_64  *L, SuperMatrix_64 *U,
              SuperMatrix_64 *B, SuperLUStat_t_64 *stat, long *info)


       void zgssv_64(superlu_options_t_64 *options,  SuperMatrix_64  *A,  long
              *perm_c,  long  *perm_r,  SuperMatrix_64  *L, SuperMatrix_64 *U,
              SuperMatrix_64 *B, SuperLUStat_t_64 *stat, long *info)


PURPOSE
       gssv solves the system of linear equations A*X=B, using the LU  factor-
       ization from sgstrf. It performs the following steps:

       If A is stored column-wise (A->Stype = SLU_NC):

       o   Permute  the  columns of A, forming A*Pc, where Pc is a permutation
           matrix. For more details of this step, see sp_preorder.c.

       o   Factor A as Pr*A*Pc=L*U with the permutation Pr determined by Gaus-
           sian elimination with partial pivoting.  L is unit lower triangular
           with offdiagonal entries bounded by 1 in magnitude, and U is  upper
           triangular.

       o   Solve the system of equations A*X=B using the factored form of A.

If  A is stored row-wise (A->Stype = SLU_NR), apply the above algorithm to the
transpose of A:

o   Permute columns of transpose(A)  (rows  of  A),  forming  transpose(A)*Pc,
    where  Pc  is  a  permutation  matrix.  For more details of this step, see
    sp_preorder.c.

o   Factor A as Pr*transpose(A)*Pc=L*U with the permutation Pr  determined  by
    Gaussian  elimination  with  partial pivoting.  L is unit lower triangular
    with offdiagonal entries bounded by 1 in magnitude, and U is upper  trian-
    gular.

o   Solve the system of equations A*X=B using the factored form of A.


ARGUMENTS
       superlu_options_t *options (input)
              The structure defines the input parameters to control how the LU
              decomposition will be performed  and  how  the  system  will  be
              solved.


       SuperMatrix *A (input)
              Matrix  A  in A*X=B, of dimension (A->nrow, A->ncol). The number
              of linear equations is A->nrow. Currently, the type of A can be:
              Stype = SLU_NC; Dtype = SLU_S; Mtype = SLU_GE.
              In the future, more general A may be handled.


       int *perm_c (input/output)
              If  A->Stype = SLU_NC, column permutation vector of size A->ncol
              which defines the permutation matrix Pc;  perm_c[i]  =  j  means
              column i of A is in position j in A*Pc.
              If  A->Stype = SLU_NR, column permutation vector of size A->nrow
              which describes permutation of columns of transpose(A) (rows  of
              A) as described above.
              If options->ColPerm = MY_PERMC or options->Fact = SamePattern or
              options->Fact = SamePattern_SameRowPerm, it is  an  input  argu-
              ment.   On exit, perm_c may be overwritten by the product of the
              input perm_c and a permutation that postorders  the  elimination
              tree  of  Pc'*A'*A*Pc;  perm_c is not changed if the elimination
              tree is already in postorder.
              Otherwise, it is an output argument.


       int *perm_r (input/output)
              If A->Stype = SLU_NC, row permutation vector  of  size  A->nrow,
              which  defines  the  permutation matrix Pr, and is determined by
              partial pivoting.  perm_r[i] = j means row i of A is in position
              j in Pr*A.
              If  A->Stype = SLU_NR, permutation vector of size A->ncol, which
              determines permutation of rows of transpose(A) (columns of A) as
              described above.
              If  options->RowPerm  =  MY_PERMR  or  options->Fact  = SamePat-
              tern_SameRowPerm, perm_r is an input argument.
              Otherwise it is an output argument.


       SuperMatrix *L (output)
              The factor L from the factorization
              Pr*A*Pc=L*U              (if A->Stype = SLU_NC) or
              Pr*transpose(A)*Pc=L*U   (if  A->Stype  =  SLU_NR).   Uses  com-
              pressed row subscripts storage for supernodes, i.e.,
              L has types: Stype = SLU_SC, Dtype = SLU_S, Mtype = SLU_TRLU.


       SuperMatrix *U (output)
              The factor U from the factorization
              Pr*A*Pc=L*U              (if A->Stype = SLU_NC) or
              Pr*transpose(A)*Pc=L*U   (if A->Stype = SLU_NR).
              Uses  column-wise  storage  scheme,  i.e.,  U has types: Stype =
              SLU_NC, Dtype = SLU_S, Mtype = SLU_TRU.


       SuperMatrix *B (input/output)
              On entry, the right hand side matrix B.
              On exit, the solution matrix if info = 0.
              B has types: Stype = SLU_DN, Dtype = SLU_S, Mtype = SLU_GE.


       SuperLUStat_t *stat (output)
              Records the statistics on runtime and  floating-point  operation
              count.

              int *info (output)

            = 0:
                 successful exit

            < 0: if info = -i, the i-th argument had an illegal value

            > 0: if info = i, and i is

                 <= A->ncol: U(i,i)  is  exactly  zero.  The factorization has
                             been completed, but the factor U is exactly  sin-
                             gular,  and  division by zero will occur if it is
                             used to solve a system of equations.

                 > A->ncol:  number of bytes allocated when memory  allocation
                             failure occurred, plus A->ncol.


SEE ALSO
       SuperMatrix

       set_default_options

       StatInit

       StatFree

       gstrf

       http://crd.lbl.gov/~xiaoye/SuperLU/

       James  W.  Demmel,  Stanley C. Eisenstat, John R. Gilbert, Xiaoye S. Li
       and Joseph W. H. Liu, "A supernodal approach to sparse  partial  pivot-
       ing",  SIAM J. Matrix Analysis and Applications, Vol. 20, Num. 3, 1999,
       pp. 720-755.



                                  7 Nov 2015                          gssv(3P)