SuperLU  5.0
Macros | Functions
cgsrfs.c File Reference

Improves computed solution to a system of inear equations. More...

#include <math.h>
#include "slu_cdefs.h"
Include dependency graph for cgsrfs.c:

Macros

#define ITMAX   5
 

Functions

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, SuperLUStat_t *stat, int *info)
 

Detailed Description

– SuperLU routine (version 5.1) –
Univ. of California Berkeley, Xerox Palo Alto Research Center,
and Lawrence Berkeley National Lab.
October 15, 2003
Modified from lapack routine CGERFS
Last modified: December 3, 2015

Macro Definition Documentation

#define ITMAX   5

Function Documentation

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,
SuperLUStat_t stat,
int *  info 
)

Purpose

  CGSRFS improves the computed solution to a system of linear   
  equations and provides error bounds and backward error estimates for 
  the solution.
  If equilibration was performed, the system becomes:
          (diag(R)*A_original*diag(C)) * X = diag(R)*B_original.
  See supermatrix.h for the definition of 'SuperMatrix' structure.

Arguments

trans   (input) trans_t
         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)
  A       (input) SuperMatrix*
          The original matrix A in the system, or the scaled A if
          equilibration was done. The type of A can be:
          Stype = SLU_NC, Dtype = SLU_C, Mtype = SLU_GE.
  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 = SLU_SC, Dtype = SLU_C, Mtype = SLU_TRLU.
  U       (input) SuperMatrix*
          The factor U from the factorization Pr*A*Pc=L*U as computed by
          cgstrf(). Use column-wise storage scheme, 
          i.e., U has types: Stype = SLU_NC, Dtype = SLU_C, Mtype = SLU_TRU.
  perm_c  (input) int*, dimension (A->ncol)
          Column permutation vector, which defines the 
          permutation matrix Pc; perm_c[i] = j means column i of A is 
          in position j in A*Pc.
  perm_r  (input) int*, dimension (A->nrow)
          Row permutation vector, which defines the permutation matrix Pr;
          perm_r[i] = j means row i of A is in position j in Pr*A.
  equed   (input) Specifies the form of equilibration that was done.
          = 'N': No equilibration.
          = 'R': Row equilibration, i.e., A was premultiplied by diag(R).
          = 'C': Column equilibration, i.e., A was postmultiplied by
                 diag(C).
          = 'B': Both row and column equilibration, i.e., A was replaced 
                 by diag(R)*A*diag(C).
  R       (input) float*, dimension (A->nrow)
          The row scale factors for A.
          If equed = 'R' or 'B', A is premultiplied by diag(R).
          If equed = 'N' or 'C', R is not accessed.
  C       (input) float*, dimension (A->ncol)
          The column scale factors for A.
          If equed = 'C' or 'B', A is postmultiplied by diag(C).
          If equed = 'N' or 'R', C is not accessed.
  B       (input) SuperMatrix*
          B has types: Stype = SLU_DN, Dtype = SLU_C, Mtype = SLU_GE.
          The right hand side matrix B.
          if equed = 'R' or 'B', B is premultiplied by diag(R).
  X       (input/output) SuperMatrix*
          X has types: Stype = SLU_DN, Dtype = SLU_C, Mtype = SLU_GE.
          On entry, the solution matrix X, as computed by cgstrs().
          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.
  FERR    (output) float*, dimension (B->ncol)   
          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 
          element in (X(j) - XTRUE) divided by the magnitude of the   
          largest element in X(j).  The estimate is as reliable as   
          the estimate for RCOND, and is almost always a slight   
          overestimate of the true error.
  BERR    (output) float*, dimension (B->ncol)   
          The componentwise relative backward error of each solution   
          vector X(j) (i.e., the smallest relative change in   
          any element of A or B that makes X(j) an exact solution).
  stat     (output) SuperLUStat_t*
           Record the statistics on runtime and floating-point operation count.
           See util.h for the definition of 'SuperLUStat_t'.
  info    (output) int*   
          = 0:  successful exit   
           < 0:  if INFO = -i, the i-th argument had an illegal value

Internal Parameters

   ITMAX is the maximum number of steps of iterative refinement.
 

Here is the call graph for this function: