PetscErrorCode MatSolve_SuperLU_Private(Mat A,Vec b,Vec x)
{
Mat_SuperLU *lu = (Mat_SuperLU*)A->spptr;
PetscScalar *barray,*xarray;
PetscErrorCode ierr;
PetscInt info,i,n=x->map->n;
PetscReal ferr,berr;
PetscFunctionBegin;
if ( lu->lwork == -1 ) {
PetscFunctionReturn(0);
}
lu->B.ncol = 1; /* Set the number of right-hand side */
if (lu->options.Equil && !lu->rhs_dup){
/* superlu overwrites b when Equil is used, thus create rhs_dup to keep user's b unchanged */
ierr = PetscMalloc(n*sizeof(PetscScalar),&lu->rhs_dup);CHKERRQ(ierr);
}
if (lu->options.Equil){
/* Copy b into rsh_dup */
ierr = VecGetArray(b,&barray);CHKERRQ(ierr);
ierr = PetscMemcpy(lu->rhs_dup,barray,n*sizeof(PetscScalar));CHKERRQ(ierr);
ierr = VecRestoreArray(b,&barray);CHKERRQ(ierr);
barray = lu->rhs_dup;
} else {
ierr = VecGetArray(b,&barray);CHKERRQ(ierr);
}
ierr = VecGetArray(x,&xarray);CHKERRQ(ierr);
#if defined(PETSC_USE_COMPLEX)
((DNformat*)lu->B.Store)->nzval = (doublecomplex*)barray;
((DNformat*)lu->X.Store)->nzval = (doublecomplex*)xarray;
#else
((DNformat*)lu->B.Store)->nzval = barray;
((DNformat*)lu->X.Store)->nzval = xarray;
#endif
lu->options.Fact = FACTORED; /* Indicate the factored form of A is supplied. */
if (A->factortype == MAT_FACTOR_LU){
#if defined(PETSC_USE_COMPLEX)
zgssvx(&lu->options, &lu->A, lu->perm_c, lu->perm_r, lu->etree, lu->equed, lu->R, lu->C,
&lu->L, &lu->U, lu->work, lu->lwork, &lu->B, &lu->X, &lu->rpg, &lu->rcond, &ferr, &berr,
&lu->mem_usage, &lu->stat, &info);
#else
dgssvx(&lu->options, &lu->A, lu->perm_c, lu->perm_r, lu->etree, lu->equed, lu->R, lu->C,
&lu->L, &lu->U, lu->work, lu->lwork, &lu->B, &lu->X, &lu->rpg, &lu->rcond, &ferr, &berr,
&lu->mem_usage, &lu->stat, &info);
#endif
} else if (A->factortype == MAT_FACTOR_ILU){
#if defined(PETSC_USE_COMPLEX)
zgsisx(&lu->options, &lu->A, lu->perm_c, lu->perm_r, lu->etree, lu->equed, lu->R, lu->C,
&lu->L, &lu->U, lu->work, lu->lwork, &lu->B, &lu->X, &lu->rpg, &lu->rcond,
&lu->mem_usage, &lu->stat, &info);
#else
dgsisx(&lu->options, &lu->A, lu->perm_c, lu->perm_r, lu->etree, lu->equed, lu->R, lu->C,
&lu->L, &lu->U, lu->work, lu->lwork, &lu->B, &lu->X, &lu->rpg, &lu->rcond,
&lu->mem_usage, &lu->stat, &info);
#endif
} else {
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Factor type not supported");
}
if (!lu->options.Equil){
ierr = VecRestoreArray(b,&barray);CHKERRQ(ierr);
}
ierr = VecRestoreArray(x,&xarray);CHKERRQ(ierr);
if ( !info || info == lu->A.ncol+1 ) {
if ( lu->options.IterRefine ) {
ierr = PetscPrintf(PETSC_COMM_SELF,"Iterative Refinement:\n");
ierr = PetscPrintf(PETSC_COMM_SELF," %8s%8s%16s%16s\n", "rhs", "Steps", "FERR", "BERR");
for (i = 0; i < 1; ++i)
ierr = PetscPrintf(PETSC_COMM_SELF," %8d%8d%16e%16e\n", i+1, lu->stat.RefineSteps, ferr, berr);
}
} else if ( info > 0 ){
if ( lu->lwork == -1 ) {
ierr = PetscPrintf(PETSC_COMM_SELF," ** Estimated memory: %D bytes\n", info - lu->A.ncol);
} else {
ierr = PetscPrintf(PETSC_COMM_SELF," Warning: gssvx() returns info %D\n",info);
}
} else if (info < 0){
SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_LIB, "info = %D, the %D-th argument in gssvx() had an illegal value", info,-info);
}
if ( lu->options.PrintStat ) {
ierr = PetscPrintf(PETSC_COMM_SELF,"MatSolve__SuperLU():\n");
StatPrint(&lu->stat);
}
PetscFunctionReturn(0);
}
int main(int argc, char *argv[])
{
void dmatvec_mult(double alpha, double x[], double beta, double y[]);
void dpsolve(int n, double x[], double y[]);
extern int dfgmr( int n,
void (*matvec_mult)(double, double [], double, double []),
void (*psolve)(int n, double [], double[]),
double *rhs, double *sol, double tol, int restrt, int *itmax,
FILE *fits);
extern int dfill_diag(int n, NCformat *Astore);
char equed[1] = {'B'};
yes_no_t equil;
trans_t trans;
SuperMatrix A, L, U;
SuperMatrix B, X;
NCformat *Astore;
NCformat *Ustore;
SCformat *Lstore;
double *a;
int *asub, *xa;
int *etree;
int *perm_c; /* column permutation vector */
int *perm_r; /* row permutations from partial pivoting */
int nrhs, ldx, lwork, info, m, n, nnz;
double *rhsb, *rhsx, *xact;
double *work = NULL;
double *R, *C;
double u, rpg, rcond;
double zero = 0.0;
double one = 1.0;
mem_usage_t mem_usage;
superlu_options_t options;
SuperLUStat_t stat;
int restrt, iter, maxit, i;
double resid;
double *x, *b;
#ifdef DEBUG
extern int num_drop_L, num_drop_U;
#endif
#if ( DEBUGlevel>=1 )
CHECK_MALLOC("Enter main()");
#endif
/* Defaults */
lwork = 0;
nrhs = 1;
equil = YES;
u = 0.1; /* u=1.0 for complete factorization */
trans = NOTRANS;
/* Set the default input options:
options.Fact = DOFACT;
options.Equil = YES;
options.ColPerm = COLAMD;
options.DiagPivotThresh = 0.1; //different from complete LU
options.Trans = NOTRANS;
options.IterRefine = NOREFINE;
options.SymmetricMode = NO;
options.PivotGrowth = NO;
options.ConditionNumber = NO;
options.PrintStat = YES;
options.RowPerm = LargeDiag;
options.ILU_DropTol = 1e-4;
options.ILU_FillTol = 1e-2;
options.ILU_FillFactor = 10.0;
options.ILU_DropRule = DROP_BASIC | DROP_AREA;
options.ILU_Norm = INF_NORM;
options.ILU_MILU = SILU;
*/
ilu_set_default_options(&options);
/* Modify the defaults. */
options.PivotGrowth = YES; /* Compute reciprocal pivot growth */
options.ConditionNumber = YES;/* Compute reciprocal condition number */
if ( lwork > 0 ) {
work = SUPERLU_MALLOC(lwork);
if ( !work ) ABORT("Malloc fails for work[].");
}
/* Read matrix A from a file in Harwell-Boeing format.*/
if (argc < 2)
{
printf("Usage:\n%s [OPTION] < [INPUT] > [OUTPUT]\nOPTION:\n"
"-h -hb:\n\t[INPUT] is a Harwell-Boeing format matrix.\n"
"-r -rb:\n\t[INPUT] is a Rutherford-Boeing format matrix.\n"
"-t -triplet:\n\t[INPUT] is a triplet format matrix.\n",
argv[0]);
return 0;
}
else
{
switch (argv[1][1])
{
case 'H':
case 'h':
printf("Input a Harwell-Boeing format matrix:\n");
dreadhb(&m, &n, &nnz, &a, &asub, &xa);
break;
case 'R':
case 'r':
printf("Input a Rutherford-Boeing format matrix:\n");
dreadrb(&m, &n, &nnz, &a, &asub, &xa);
break;
case 'T':
case 't':
printf("Input a triplet format matrix:\n");
dreadtriple(&m, &n, &nnz, &a, &asub, &xa);
break;
default:
printf("Unrecognized format.\n");
return 0;
}
}
dCreate_CompCol_Matrix(&A, m, n, nnz, a, asub, xa, SLU_NC, SLU_D, SLU_GE);
Astore = A.Store;
dfill_diag(n, Astore);
printf("Dimension %dx%d; # nonzeros %d\n", A.nrow, A.ncol, Astore->nnz);
fflush(stdout);
if ( !(rhsb = doubleMalloc(m * nrhs)) ) ABORT("Malloc fails for rhsb[].");
if ( !(rhsx = doubleMalloc(m * nrhs)) ) ABORT("Malloc fails for rhsx[].");
dCreate_Dense_Matrix(&B, m, nrhs, rhsb, m, SLU_DN, SLU_D, SLU_GE);
dCreate_Dense_Matrix(&X, m, nrhs, rhsx, m, SLU_DN, SLU_D, SLU_GE);
xact = doubleMalloc(n * nrhs);
ldx = n;
dGenXtrue(n, nrhs, xact, ldx);
dFillRHS(trans, nrhs, xact, ldx, &A, &B);
if ( !(etree = intMalloc(n)) ) ABORT("Malloc fails for etree[].");
if ( !(perm_r = intMalloc(m)) ) ABORT("Malloc fails for perm_r[].");
if ( !(perm_c = intMalloc(n)) ) ABORT("Malloc fails for perm_c[].");
if ( !(R = (double *) SUPERLU_MALLOC(A.nrow * sizeof(double))) )
ABORT("SUPERLU_MALLOC fails for R[].");
if ( !(C = (double *) SUPERLU_MALLOC(A.ncol * sizeof(double))) )
ABORT("SUPERLU_MALLOC fails for C[].");
info = 0;
#ifdef DEBUG
num_drop_L = 0;
num_drop_U = 0;
#endif
/* Initialize the statistics variables. */
StatInit(&stat);
/* Compute the incomplete factorization and compute the condition number
and pivot growth using dgsisx. */
dgsisx(&options, &A, perm_c, perm_r, etree, equed, R, C, &L, &U, work,
lwork, &B, &X, &rpg, &rcond, &mem_usage, &stat, &info);
Lstore = (SCformat *) L.Store;
Ustore = (NCformat *) U.Store;
printf("dgsisx(): info %d\n", info);
if (info > 0 || rcond < 1e-8 || rpg > 1e8)
printf("WARNING: This preconditioner might be unstable.\n");
if ( info == 0 || info == n+1 ) {
if ( options.PivotGrowth == YES )
printf("Recip. pivot growth = %e\n", rpg);
if ( options.ConditionNumber == YES )
printf("Recip. condition number = %e\n", rcond);
} else if ( info > 0 && lwork == -1 ) {
printf("** Estimated memory: %d bytes\n", info - n);
}
printf("n(A) = %d, nnz(A) = %d\n", n, Astore->nnz);
printf("No of nonzeros in factor L = %d\n", Lstore->nnz);
printf("No of nonzeros in factor U = %d\n", Ustore->nnz);
printf("No of nonzeros in L+U = %d\n", Lstore->nnz + Ustore->nnz - n);
printf("Fill ratio: nnz(F)/nnz(A) = %.3f\n",
((double)(Lstore->nnz) + (double)(Ustore->nnz) - (double)n)
/ (double)Astore->nnz);
printf("L\\U MB %.3f\ttotal MB needed %.3f\n",
mem_usage.for_lu/1e6, mem_usage.total_needed/1e6);
fflush(stdout);
/* Set the global variables. */
GLOBAL_A = &A;
GLOBAL_L = &L;
GLOBAL_U = &U;
GLOBAL_STAT = &stat;
GLOBAL_PERM_C = perm_c;
GLOBAL_PERM_R = perm_r;
/* Set the variables used by GMRES. */
restrt = SUPERLU_MIN(n / 3 + 1, 50);
maxit = 1000;
iter = maxit;
resid = 1e-8;
if (!(b = doubleMalloc(m))) ABORT("Malloc fails for b[].");
if (!(x = doubleMalloc(n))) ABORT("Malloc fails for x[].");
if (info <= n + 1)
{
int i_1 = 1;
double maxferr = 0.0, nrmA, nrmB, res, t;
double temp;
extern double dnrm2_(int *, double [], int *);
extern void daxpy_(int *, double *, double [], int *, double [], int *);
/* Call GMRES. */
for (i = 0; i < n; i++) b[i] = rhsb[i];
for (i = 0; i < n; i++) x[i] = zero;
t = SuperLU_timer_();
dfgmr(n, dmatvec_mult, dpsolve, b, x, resid, restrt, &iter, stdout);
t = SuperLU_timer_() - t;
/* Output the result. */
nrmA = dnrm2_(&(Astore->nnz), (double *)((DNformat *)A.Store)->nzval,
&i_1);
nrmB = dnrm2_(&m, b, &i_1);
sp_dgemv("N", -1.0, &A, x, 1, 1.0, b, 1);
res = dnrm2_(&m, b, &i_1);
resid = res / nrmB;
printf("||A||_F = %.1e, ||B||_2 = %.1e, ||B-A*X||_2 = %.1e, "
"relres = %.1e\n", nrmA, nrmB, res, resid);
if (iter >= maxit)
{
if (resid >= 1.0) iter = -180;
else if (resid > 1e-8) iter = -111;
}
printf("iteration: %d\nresidual: %.1e\nGMRES time: %.2f seconds.\n",
iter, resid, t);
/* Scale the solution back if equilibration was performed. */
if (*equed == 'C' || *equed == 'B')
for (i = 0; i < n; i++) x[i] *= C[i];
for (i = 0; i < m; i++) {
maxferr = SUPERLU_MAX(maxferr, fabs(x[i] - xact[i]));
}
printf("||X-X_true||_oo = %.1e\n", maxferr);
}
#ifdef DEBUG
printf("%d entries in L and %d entries in U dropped.\n",
num_drop_L, num_drop_U);
#endif
fflush(stdout);
if ( options.PrintStat ) StatPrint(&stat);
StatFree(&stat);
SUPERLU_FREE (rhsb);
SUPERLU_FREE (rhsx);
SUPERLU_FREE (xact);
SUPERLU_FREE (etree);
SUPERLU_FREE (perm_r);
SUPERLU_FREE (perm_c);
SUPERLU_FREE (R);
SUPERLU_FREE (C);
Destroy_CompCol_Matrix(&A);
Destroy_SuperMatrix_Store(&B);
Destroy_SuperMatrix_Store(&X);
if ( lwork >= 0 ) {
Destroy_SuperNode_Matrix(&L);
Destroy_CompCol_Matrix(&U);
}
SUPERLU_FREE(b);
SUPERLU_FREE(x);
#if ( DEBUGlevel>=1 )
CHECK_MALLOC("Exit main()");
#endif
return 0;
}
PetscErrorCode MatLUFactorNumeric_SuperLU(Mat F,Mat A,const MatFactorInfo *info)
{
Mat_SuperLU *lu = (Mat_SuperLU*)F->spptr;
Mat_SeqAIJ *aa;
PetscErrorCode ierr;
PetscInt sinfo;
PetscReal ferr, berr;
NCformat *Ustore;
SCformat *Lstore;
PetscFunctionBegin;
if (lu->flg == SAME_NONZERO_PATTERN){ /* successing numerical factorization */
lu->options.Fact = SamePattern;
/* Ref: ~SuperLU_3.0/EXAMPLE/dlinsolx2.c */
Destroy_SuperMatrix_Store(&lu->A);
if (lu->options.Equil){
ierr = MatCopy_SeqAIJ(A,lu->A_dup,SAME_NONZERO_PATTERN);CHKERRQ(ierr);
}
if ( lu->lwork >= 0 ) {
Destroy_SuperNode_Matrix(&lu->L);
Destroy_CompCol_Matrix(&lu->U);
lu->options.Fact = SamePattern;
}
}
/* Create the SuperMatrix for lu->A=A^T:
Since SuperLU likes column-oriented matrices,we pass it the transpose,
and then solve A^T X = B in MatSolve(). */
if (lu->options.Equil){
aa = (Mat_SeqAIJ*)(lu->A_dup)->data;
} else {
aa = (Mat_SeqAIJ*)(A)->data;
}
#if defined(PETSC_USE_COMPLEX)
zCreate_CompCol_Matrix(&lu->A,A->cmap->n,A->rmap->n,aa->nz,(doublecomplex*)aa->a,aa->j,aa->i,
SLU_NC,SLU_Z,SLU_GE);
#else
dCreate_CompCol_Matrix(&lu->A,A->cmap->n,A->rmap->n,aa->nz,aa->a,aa->j,aa->i,
SLU_NC,SLU_D,SLU_GE);
#endif
/* Numerical factorization */
lu->B.ncol = 0; /* Indicate not to solve the system */
if (F->factortype == MAT_FACTOR_LU){
#if defined(PETSC_USE_COMPLEX)
zgssvx(&lu->options, &lu->A, lu->perm_c, lu->perm_r, lu->etree, lu->equed, lu->R, lu->C,
&lu->L, &lu->U, lu->work, lu->lwork, &lu->B, &lu->X, &lu->rpg, &lu->rcond, &ferr, &berr,
&lu->mem_usage, &lu->stat, &sinfo);
#else
dgssvx(&lu->options, &lu->A, lu->perm_c, lu->perm_r, lu->etree, lu->equed, lu->R, lu->C,
&lu->L, &lu->U, lu->work, lu->lwork, &lu->B, &lu->X, &lu->rpg, &lu->rcond, &ferr, &berr,
&lu->mem_usage, &lu->stat, &sinfo);
#endif
} else if (F->factortype == MAT_FACTOR_ILU){
/* Compute the incomplete factorization, condition number and pivot growth */
#if defined(PETSC_USE_COMPLEX)
zgsisx(&lu->options, &lu->A, lu->perm_c, lu->perm_r,lu->etree, lu->equed, lu->R, lu->C,
&lu->L, &lu->U, lu->work, lu->lwork, &lu->B, &lu->X, &lu->rpg, &lu->rcond,
&lu->mem_usage, &lu->stat, &sinfo);
#else
dgsisx(&lu->options, &lu->A, lu->perm_c, lu->perm_r, lu->etree, lu->equed, lu->R, lu->C,
&lu->L, &lu->U, lu->work, lu->lwork, &lu->B, &lu->X, &lu->rpg, &lu->rcond,
&lu->mem_usage, &lu->stat, &sinfo);
#endif
} else {
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Factor type not supported");
}
if ( !sinfo || sinfo == lu->A.ncol+1 ) {
if ( lu->options.PivotGrowth )
ierr = PetscPrintf(PETSC_COMM_SELF," Recip. pivot growth = %e\n", lu->rpg);
if ( lu->options.ConditionNumber )
ierr = PetscPrintf(PETSC_COMM_SELF," Recip. condition number = %e\n", lu->rcond);
} else if ( sinfo > 0 ){
if ( lu->lwork == -1 ) {
ierr = PetscPrintf(PETSC_COMM_SELF," ** Estimated memory: %D bytes\n", sinfo - lu->A.ncol);
} else SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_MAT_LU_ZRPVT,"Zero pivot in row %D",sinfo);
} else { /* sinfo < 0 */
SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_LIB, "info = %D, the %D-th argument in gssvx() had an illegal value", sinfo,-sinfo);
}
if ( lu->options.PrintStat ) {
ierr = PetscPrintf(PETSC_COMM_SELF,"MatLUFactorNumeric_SuperLU():\n");
StatPrint(&lu->stat);
Lstore = (SCformat *) lu->L.Store;
Ustore = (NCformat *) lu->U.Store;
ierr = PetscPrintf(PETSC_COMM_SELF," No of nonzeros in factor L = %D\n", Lstore->nnz);
ierr = PetscPrintf(PETSC_COMM_SELF," No of nonzeros in factor U = %D\n", Ustore->nnz);
ierr = PetscPrintf(PETSC_COMM_SELF," No of nonzeros in L+U = %D\n", Lstore->nnz + Ustore->nnz - lu->A.ncol);
ierr = PetscPrintf(PETSC_COMM_SELF," L\\U MB %.3f\ttotal MB needed %.3f\n",
lu->mem_usage.for_lu/1e6, lu->mem_usage.total_needed/1e6);
}
lu->flg = SAME_NONZERO_PATTERN;
F->ops->solve = MatSolve_SuperLU;
F->ops->solvetranspose = MatSolveTranspose_SuperLU;
F->ops->matsolve = MatMatSolve_SuperLU;
PetscFunctionReturn(0);
}
static bool slm_solve(void* context, real_t* B, real_t* x)
{
slm_t* mat = context;
SuperMatrix* A = mat->A;
// Copy B to the rhs vector.
DNformat* rhs = mat->rhs.Store;
double* Bi = rhs->nzval;
for (int i = 0; i < mat->N; ++i)
Bi[i] = (double)B[i];
if (mat->cperm == NULL)
{
mat->cperm = intMalloc(mat->N);
mat->rperm = intMalloc(mat->N);
}
else if (mat->options.Fact != FACTORED)
{
// Jettison the existing factorization.
Destroy_SuperNode_Matrix(&mat->L);
Destroy_CompCol_Matrix(&mat->U);
}
// Do the solve.
int info = 0, lwork = 0;
void* work = NULL;
double ferr, berr;
GlobalLU_t glu; // "Global data structure" for SuperLU for helping with factorizations.
double recip_pivot_growth = 1.0, rcond = 1.0;
mem_usage_t mem_usage;
if (mat->ilu_params == NULL)
{
// Factorize if necessary.
if (mat->options.Fact == DOFACT)
{
int rhs_ncol = mat->rhs.ncol;
mat->rhs.ncol = 0;
polymec_suspend_fpe();
dgssvx(&mat->options, A, mat->cperm, mat->rperm, mat->etree, &mat->equil,
mat->R, mat->C, &mat->L, &mat->U, work, lwork, &mat->rhs, &mat->X,
&recip_pivot_growth, &rcond, &ferr, &berr, &glu, &mem_usage, &mat->stat, &info);
polymec_restore_fpe();
mat->rhs.ncol = rhs_ncol;
if ((info == 0) || (info == A->ncol+1))
{
if (mat->equil != 'N')
{
if (mat->equil == 'R')
log_debug("slm_solve: performed row equilibration.");
else if (mat->equil == 'C')
log_debug("slm_solve: performed column equilibration.");
else if (mat->equil == 'B')
log_debug("slm_solve: performed row/column equilibration.");
}
log_debug("slm_solve: L has %d nonzeros, U has %d.",
((SCformat*)mat->L.Store)->nnz, ((NCformat*)mat->U.Store)->nnz);
#ifndef NDEBUG
log_debug("slm_solve: recip pivot growth = %g, condition number = %g.",
recip_pivot_growth, rcond);
if (recip_pivot_growth < 0.01)
{
log_detail("slm_solve: WARNING: recip pivot growth for ILU factorization << 1.");
log_detail("slm_solve: WARNING: Stability of LU factorization could be poor.");
}
#endif
// Reuse the factorization.
mat->options.Fact = FACTORED;
}
else
log_debug("slm_solve: LU factorization failed.");
}
// Solve the factored system.
if ((info == 0) || (info == A->ncol+1))
{
polymec_suspend_fpe();
dgssvx(&mat->options, A, mat->cperm, mat->rperm, mat->etree, &mat->equil,
mat->R, mat->C, &mat->L, &mat->U, work, lwork, &mat->rhs,
&mat->X, &recip_pivot_growth, &rcond, &ferr, &berr, &glu, &mem_usage,
&mat->stat, &info);
polymec_restore_fpe();
}
}
else
{
// Incomplete LU factorization.
// Factorize if necessary.
if (mat->options.Fact == DOFACT)
{
int rhs_ncol = mat->rhs.ncol;
mat->rhs.ncol = 0;
polymec_suspend_fpe();
dgsisx(&mat->options, A, mat->cperm, mat->rperm, mat->etree, &mat->equil,
mat->R, mat->C, &mat->L, &mat->U, NULL, 0, &mat->rhs, &mat->X,
&recip_pivot_growth, &rcond, &glu, &mem_usage, &mat->stat, &info);
polymec_restore_fpe();
mat->rhs.ncol = rhs_ncol;
if ((info == 0) || (info == A->ncol+1))
{
if (mat->equil != 'N')
{
if (mat->equil == 'R')
log_debug("slm_solve: performed row equilibration.");
else if (mat->equil == 'C')
log_debug("slm_solve: performed column equilibration.");
else if (mat->equil == 'B')
log_debug("slm_solve: performed row/column equilibration.");
}
#ifndef NDEBUG
log_debug("slm_solve: recip pivot growth = %g, condition number = %g.",
recip_pivot_growth, rcond);
if (recip_pivot_growth < 0.01)
{
log_detail("slm_solve: WARNING: recip pivot growth for ILU factorization << 1.");
log_detail("slm_solve: WARNING: Stability of LU factorization could be poor.");
}
#endif
// Reuse the factorization.
mat->options.Fact = FACTORED;
}
else
log_debug("slm_solve: incomplete LU factorization failed.");
}
// Solve the factored system.
if ((info == 0) || (info == A->ncol+1))
{
polymec_suspend_fpe();
dgsisx(&mat->options, A, mat->cperm, mat->rperm, mat->etree, &mat->equil,
mat->R, mat->C, &mat->L, &mat->U, NULL, 0, &mat->rhs, &mat->X,
&recip_pivot_growth, &rcond, &glu, &mem_usage, &mat->stat, &info);
polymec_restore_fpe();
}
}
bool success = ((info == 0) || (info == A->ncol+1));
if (success)
{
// Copy the output vector to x.
double* X = ((DNformat*)mat->X.Store)->nzval;
for (int i = 0; i < mat->N; ++i)
x[i] = (real_t)X[i];
}
else
{
ASSERT(info > 0);
if (mat->ilu_params == NULL)
{
log_debug("slm_solve: LU solve failed.");
log_debug("slm_solve: (U is singular: U(%d, %d) = 0.)", info-1, info-1);
}
else
{
log_debug("slm_solve: ILU solve failed.");
if (info < A->ncol)
log_debug("slm_solve: (number of zero pivots in U = %d.)", info);
else if (info == (A->ncol + 1))
log_debug("slm_solve: (U is nonsingular but rcond = %g.)", rcond);
else
log_debug("slm_solve: (Memory allocation failure.)");
}
}
return success;
}
