Go to main content
Oracle Developer Studio 12.5 Man Pages

Exit Print View

Updated: June 2017
 
 

zgsrfs (3p)

Name

zgsrfs - improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solution. It is a SuperLU routine.

Synopsis

#include <sunperf.h>


void  sgsrfs(trans_t trans, SuperMatrix *A, SuperMatrix *L, SuperMatrix
*U, int *perm_c, int *perm_r, char *equed, float *R,  float  *C,
SuperMatrix *B, SuperMatrix *X, float *ferr, float *berr, Super-
LUStat_t *stat, int *info)


void dgsrfs(trans_t trans, SuperMatrix *A, SuperMatrix *L,  SuperMatrix
*U, int *perm_c, int *perm_r, char *equed, double *R, double *C,
SuperMatrix *B, SuperMatrix  *X,  double  *ferr,  double  *berr,
SuperLUStat_t *stat, int *info)


void  cgsrfs(trans_t trans, SuperMatrix *A, SuperMatrix *L, SuperMatrix
*U, int *perm_c, int *perm_r, char *equed, float *R,  float  *C,
SuperMatrix *B, SuperMatrix *X, float *ferr, float *berr, Super-
LUStat_t *stat, int *info)


void zgsrfs(trans_t trans, SuperMatrix *A, SuperMatrix *L,  SuperMatrix
*U, int *perm_c, int *perm_r, char *equed, double *R, double *C,
SuperMatrix *B, SuperMatrix  *X,  double  *ferr,  double  *berr,
SuperLUStat_t *stat, int *info)


void  sgsrfs_64(trans_t  trans,  SuperMatrix_64  *A, SuperMatrix_64 *L,
SuperMatrix_64 *U, long  *perm_c,  long  *perm_r,  char  *equed,
float  *R, float *C, SuperMatrix_64 *B, SuperMatrix_64 *X, float
*ferr, float *berr, SuperLUStat_t_64 *stat, long *info)


void dgsrfs_64(trans_t trans,  SuperMatrix_64  *A,  SuperMatrix_64  *L,
SuperMatrix_64 *U, long *perm_c, long *perm_r, char *equed, dou-
ble *R, double *C, SuperMatrix_64 *B, SuperMatrix_64 *X,  double
*ferr, double *berr, SuperLUStat_t_64 *stat, long *info)


void  cgsrfs_64(trans_t  trans,  SuperMatrix_64  *A, SuperMatrix_64 *L,
SuperMatrix_64 *U, long  *perm_c,  long  *perm_r,  char  *equed,
float  *R, float *C, SuperMatrix_64 *B, SuperMatrix_64 *X, float
*ferr, float *berr, SuperLUStat_t_64 *stat, long *info)


void zgsrfs_64(trans_t trans,  SuperMatrix_64  *A,  SuperMatrix_64  *L,
SuperMatrix_64 *U, long *perm_c, long *perm_r, char *equed, dou-
ble *R, double *C, SuperMatrix_64 *B, SuperMatrix_64 *X,  double
*ferr, double *berr, SuperLUStat_t_64 *stat, long *info)

Description

Oracle Solaris Studio Performance Library                            gsrfs(3P)



NAME
       gsrfs:  cgsrfs, dgsrfs, sgsrfs, zgsrfs - improves the computed solution
       to a system of linear equations and provides error bounds and  backward
       error estimates for the solution.  It is a SuperLU routine.


SYNOPSIS
       #include <sunperf.h>


       void  sgsrfs(trans_t trans, SuperMatrix *A, SuperMatrix *L, SuperMatrix
              *U, int *perm_c, int *perm_r, char *equed, float *R,  float  *C,
              SuperMatrix *B, SuperMatrix *X, float *ferr, float *berr, Super-
              LUStat_t *stat, int *info)


       void dgsrfs(trans_t trans, SuperMatrix *A, SuperMatrix *L,  SuperMatrix
              *U, int *perm_c, int *perm_r, char *equed, double *R, double *C,
              SuperMatrix *B, SuperMatrix  *X,  double  *ferr,  double  *berr,
              SuperLUStat_t *stat, int *info)


       void  cgsrfs(trans_t trans, SuperMatrix *A, SuperMatrix *L, SuperMatrix
              *U, int *perm_c, int *perm_r, char *equed, float *R,  float  *C,
              SuperMatrix *B, SuperMatrix *X, float *ferr, float *berr, Super-
              LUStat_t *stat, int *info)


       void zgsrfs(trans_t trans, SuperMatrix *A, SuperMatrix *L,  SuperMatrix
              *U, int *perm_c, int *perm_r, char *equed, double *R, double *C,
              SuperMatrix *B, SuperMatrix  *X,  double  *ferr,  double  *berr,
              SuperLUStat_t *stat, int *info)


       void  sgsrfs_64(trans_t  trans,  SuperMatrix_64  *A, SuperMatrix_64 *L,
              SuperMatrix_64 *U, long  *perm_c,  long  *perm_r,  char  *equed,
              float  *R, float *C, SuperMatrix_64 *B, SuperMatrix_64 *X, float
              *ferr, float *berr, SuperLUStat_t_64 *stat, long *info)


       void dgsrfs_64(trans_t trans,  SuperMatrix_64  *A,  SuperMatrix_64  *L,
              SuperMatrix_64 *U, long *perm_c, long *perm_r, char *equed, dou-
              ble *R, double *C, SuperMatrix_64 *B, SuperMatrix_64 *X,  double
              *ferr, double *berr, SuperLUStat_t_64 *stat, long *info)


       void  cgsrfs_64(trans_t  trans,  SuperMatrix_64  *A, SuperMatrix_64 *L,
              SuperMatrix_64 *U, long  *perm_c,  long  *perm_r,  char  *equed,
              float  *R, float *C, SuperMatrix_64 *B, SuperMatrix_64 *X, float
              *ferr, float *berr, SuperLUStat_t_64 *stat, long *info)


       void zgsrfs_64(trans_t trans,  SuperMatrix_64  *A,  SuperMatrix_64  *L,
              SuperMatrix_64 *U, long *perm_c, long *perm_r, char *equed, dou-
              ble *R, double *C, SuperMatrix_64 *B, SuperMatrix_64 *X,  double
              *ferr, double *berr, SuperLUStat_t_64 *stat, long *info)


PURPOSE
       gsrfs  improves  the  computed solution to a system of linear equations
       and provides error bounds and backward error estimates  for  the  solu-
       tion.  If equilibration was performed, the system becomes:
       (diag(R)*A_original*diag(C)) * X = diag(R)*B_original.


ARGUMENTS
       trans_t trans (input)
              Specifies the form of the system of equations:
              = NOTRANS: A * X = B (No transpose)
              = TRANS:   A'* X = B (Transpose)
              = CONJ:    A**H * X = B (Conjugate transpose)


       SuperMatrix *A (input)
              Original  matrix  A in the system, or the scaled A if equilibra-
              tion was done.  The type of A can be:
              Stype = SLU_NC; Dtype = SLU_S; Mtype = SLU_GE.


       SuperMatrix *L (input)
              The factor L from the  factorization  Pr*A=L*U.   It  uses  com-
              pressed  row  subscripts  storage  for  supernodes,  i.e., L has
              types: Stype = SLU_SC, Dtype = SLU_S, Mtype = SLU_TRLU


       SuperMatrix *U (input)
              The factor U from the factorization Pr*A*Pc=L*U.  It  uses  col-
              umn-wise  storage  scheme,  i.e.,  U  has types: Stype = SLU_NC,
              Dtype = SLU_S, Mtype = SLU_TRU.

              int *perm_c (input)
              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.


       int *perm_r (input)
              Row permutation vector of size (A->nrow) which defines the  per-
              mutation  matrix Pr.  perm_r[i] = j means row i of A is in posi-
              tion j in Pr*A.


       char *equed (input)
              Specifies the form of equilibration that was done.


            = 'N':
                   No equilibration

            = 'R': Row  equilibration,  i.e.,  A  has  been  premultiplied  by
                   diag(R).

            = 'C': Column  equilibration,  i.e.,  A has been postmultiplied by
                   diag(C).

            = 'B': Both  row  and  column  equilibration,  i.e.,  A  has  been
                   replaced by diag(R) * A * diag(C).


       float *R (input)
                   The row scale factors for A; dimension (A->nrow).
                   If equed = 'R' or 'B', A is premultiplied by diag(R).
                   If equed = 'N' or 'C', R is not accessed.



       float *C (input)
              The column scale factors for A; dimension (A->ncol).
              If equed = 'C' or 'B', A is postmultiplied by diag(C).
              If equed = 'N' or 'R', C is not accessed.


       SuperMatrix *B (input)
              The right hand side matrix B.
              B has types: Stype = SLU_DN, Dtype = SLU_S, Mtype = SLU_GE.
              If equed = 'R' or 'B', B is premultiplied by diag(R).


       SuperMatrix *X (input/output)
              X has types: Stype = SLU_DN, Dtype = SLU_S, Mtype = SLU_GE.
              On  entry,  the  solution matrix X, as computed by sgstrs().  On
              exit, the improved solution matrix X.
              if *equed = 'C' or 'B', X should be premultiplied by diag(C)  in
              order to obtain the solution to the original system.


       float *ferr (output)
              The  estimated forward error bound for each solution vector X(j)
              (the j-th column of the solution matrix X).
              If XTRUE is the true solution corresponding to X(j), ferr(j)  is
              an  estimated  upper bound for the magnitude of the largest ele-
              ment in (X(j) - XTRUE) divided by the magnitude of  the  largest
              element  in  X(j).   The estimate is as reliable as the estimate
              for condition number RCOND, and is almost always a slight  over-
              estimate of the true error.
              ferr is of dimension B->ncol.


       float *berr (output)
              The component-wise relative backward error of each solution vec-
              tor X(j) (i.e., the smallest relative change in any element of A
              or B that makes X(j) an exact solution).
              berr is of dimension B->ncol.


       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


SEE ALSO
       SuperMatrix

       set_default_options

       StatInit

       StatFree

       gstrs

       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                         gsrfs(3P)