SRC/zgsequ.c File Reference

Computes row and column scalings. More...

#include <math.h>
#include "superlu_zdefs.h"

Include dependency graph for zgsequ.c:


Functions

void zgsequ_dist (SuperMatrix *A, double *r, double *c, double *rowcnd, double *colcnd, double *amax, int_t *info)

Detailed Description


Function Documentation

void zgsequ_dist ( SuperMatrix A,
double *  r,
double *  c,
double *  rowcnd,
double *  colcnd,
double *  amax,
int_t info 
)

   
    Purpose   
    =======

    ZGSEQU_DIST computes row and column scalings intended to equilibrate an   
    M-by-N sparse matrix A and reduce its condition number. R returns the row
    scale factors and C the column scale factors, chosen to try to make   
    the largest element in each row and column of the matrix B with   
    elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1.

    R(i) and C(j) are restricted to be between SMLNUM = smallest safe   
    number and BIGNUM = largest safe number.  Use of these scaling   
    factors is not guaranteed to reduce the condition number of A but   
    works well in practice.

    See supermatrix.h for the definition of 'SuperMatrix' structure.

    Arguments   
    =========

    A       (input) SuperMatrix*
            The matrix of dimension (A->nrow, A->ncol) whose equilibration
            factors are to be computed. The type of A can be:
            Stype = SLU_NC; Dtype = SLU_Z; Mtype = SLU_GE.

    R       (output) double*, size A->nrow
            If INFO = 0 or INFO > M, R contains the row scale factors   
            for A.

    C       (output) double*, size A->ncol
            If INFO = 0,  C contains the column scale factors for A.

    ROWCND  (output) double*
            If INFO = 0 or INFO > M, ROWCND contains the ratio of the   
            smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and   
            AMAX is neither too large nor too small, it is not worth   
            scaling by R.

    COLCND  (output) double*
            If INFO = 0, COLCND contains the ratio of the smallest   
            C(i) to the largest C(i).  If COLCND >= 0.1, it is not   
            worth scaling by C.

    AMAX    (output) double*
            Absolute value of largest matrix element.  If AMAX is very   
            close to overflow or very close to underflow, the matrix   
            should be scaled.

    INFO    (output) int*
            = 0:  successful exit   
            < 0:  if INFO = -i, the i-th argument had an illegal value   
            > 0:  if INFO = i,  and i is   
                  <= M:  the i-th row of A is exactly zero   
                  >  M:  the (i-M)-th column of A is exactly zero

    ===================================================================== 


Generated on Sat Aug 29 04:22:14 2009 for SuperLUDistributed by  doxygen 1.5.9