void test07 ( void )
/******************************************************************************/
/*
Purpose:
TEST07 demonstrates SMACH.
Modified:
29 March 2007
Author:
John Burkardt
*/
{
int job;
printf ( "\n" );
printf ( "TEST07\n" );
printf ( " SMACH returns some approximate machine numbers.\n" );
printf ( "\n" );
job = 1;
printf ( " SMACH(1) = EPS = %e\n", smach ( job ) );
job = 2;
printf ( " SMACH(2) = TINY = %e\n", smach ( job ) );
job = 3;
printf ( " SMACH(3) = HUGE = %e\n", smach ( job ) );
return;
}
int main()
{
/* Local variables */
float base, emin, prec, emax, rmin, rmax, t, sfmin;
extern float smach(char *);
double rnd, eps;
eps = smach("Epsilon");
sfmin = smach("Safe minimum");
base = smach("Base");
prec = smach("Precision");
t = smach("Number of digits in mantissa");
rnd = smach("Rounding mode");
emin = smach("Minnimum exponent");
rmin = smach("Underflow threshold");
emax = smach("Largest exponent");
rmax = smach("Overflow threshold");
printf(" Epsilon = %e\n", eps);
printf(" Safe minimum = %e\n", sfmin);
printf(" Base = %.0f\n", base);
printf(" Precision = %e\n", prec);
printf(" Number of digits in mantissa = %.0f\n", t);
printf(" Rounding mode = %.0f\n", rnd);
printf(" Minimum exponent = %.0f\n", emin);
printf(" Underflow threshold = %e\n", rmin);
printf(" Largest exponent = %.0f\n", emax);
printf(" Overflow threshold = %e\n", rmax);
printf(" Reciprocal of safe minimum = %e\n", 1./sfmin);
return 0;
}
/*! \brief
*
* <pre>
* 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.
*
* </pre>
*/
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)
{
#define ITMAX 5
/* Table of constant values */
int ione = 1;
complex ndone = {-1., 0.};
complex done = {1., 0.};
/* Local variables */
NCformat *Astore;
complex *Aval;
SuperMatrix Bjcol;
DNformat *Bstore, *Xstore, *Bjcol_store;
complex *Bmat, *Xmat, *Bptr, *Xptr;
int kase;
float safe1, safe2;
int i, j, k, irow, nz, count, notran, rowequ, colequ;
int ldb, ldx, nrhs;
float s, xk, lstres, eps, safmin;
char transc[1];
trans_t transt;
complex *work;
float *rwork;
int *iwork;
int isave[3];
extern int clacon2_(int *, complex *, complex *, float *, int *, int []);
#ifdef _CRAY
extern int CCOPY(int *, complex *, int *, complex *, int *);
extern int CSAXPY(int *, complex *, complex *, int *, complex *, int *);
#else
extern int ccopy_(int *, complex *, int *, complex *, int *);
extern int caxpy_(int *, complex *, complex *, int *, complex *, int *);
#endif
Astore = A->Store;
Aval = Astore->nzval;
Bstore = B->Store;
Xstore = X->Store;
Bmat = Bstore->nzval;
Xmat = Xstore->nzval;
ldb = Bstore->lda;
ldx = Xstore->lda;
nrhs = B->ncol;
/* Test the input parameters */
*info = 0;
notran = (trans == NOTRANS);
if ( !notran && trans != TRANS && trans != CONJ ) *info = -1;
else if ( A->nrow != A->ncol || A->nrow < 0 ||
A->Stype != SLU_NC || A->Dtype != SLU_C || A->Mtype != SLU_GE )
*info = -2;
else if ( L->nrow != L->ncol || L->nrow < 0 ||
L->Stype != SLU_SC || L->Dtype != SLU_C || L->Mtype != SLU_TRLU )
*info = -3;
else if ( U->nrow != U->ncol || U->nrow < 0 ||
U->Stype != SLU_NC || U->Dtype != SLU_C || U->Mtype != SLU_TRU )
*info = -4;
else if ( ldb < SUPERLU_MAX(0, A->nrow) ||
B->Stype != SLU_DN || B->Dtype != SLU_C || B->Mtype != SLU_GE )
*info = -10;
else if ( ldx < SUPERLU_MAX(0, A->nrow) ||
X->Stype != SLU_DN || X->Dtype != SLU_C || X->Mtype != SLU_GE )
*info = -11;
if (*info != 0) {
i = -(*info);
input_error("cgsrfs", &i);
return;
}
/* Quick return if possible */
if ( A->nrow == 0 || nrhs == 0) {
for (j = 0; j < nrhs; ++j) {
ferr[j] = 0.;
berr[j] = 0.;
}
return;
}
rowequ = lsame_(equed, "R") || lsame_(equed, "B");
colequ = lsame_(equed, "C") || lsame_(equed, "B");
/* Allocate working space */
work = complexMalloc(2*A->nrow);
rwork = (float *) SUPERLU_MALLOC( A->nrow * sizeof(float) );
iwork = intMalloc(A->nrow);
if ( !work || !rwork || !iwork )
ABORT("Malloc fails for work/rwork/iwork.");
if ( notran ) {
*(unsigned char *)transc = 'N';
transt = TRANS;
} else {
*(unsigned char *)transc = 'T';
transt = NOTRANS;
}
/* NZ = maximum number of nonzero elements in each row of A, plus 1 */
nz = A->ncol + 1;
eps = smach("Epsilon");
safmin = smach("Safe minimum");
/* Set SAFE1 essentially to be the underflow threshold times the
number of additions in each row. */
safe1 = nz * safmin;
safe2 = safe1 / eps;
/* Compute the number of nonzeros in each row (or column) of A */
for (i = 0; i < A->nrow; ++i) iwork[i] = 0;
if ( notran ) {
for (k = 0; k < A->ncol; ++k)
for (i = Astore->colptr[k]; i < Astore->colptr[k+1]; ++i)
++iwork[Astore->rowind[i]];
} else {
for (k = 0; k < A->ncol; ++k)
iwork[k] = Astore->colptr[k+1] - Astore->colptr[k];
}
/* Copy one column of RHS B into Bjcol. */
Bjcol.Stype = B->Stype;
Bjcol.Dtype = B->Dtype;
Bjcol.Mtype = B->Mtype;
Bjcol.nrow = B->nrow;
Bjcol.ncol = 1;
Bjcol.Store = (void *) SUPERLU_MALLOC( sizeof(DNformat) );
if ( !Bjcol.Store ) ABORT("SUPERLU_MALLOC fails for Bjcol.Store");
Bjcol_store = Bjcol.Store;
Bjcol_store->lda = ldb;
Bjcol_store->nzval = work; /* address aliasing */
/* Do for each right hand side ... */
for (j = 0; j < nrhs; ++j) {
count = 0;
lstres = 3.;
Bptr = &Bmat[j*ldb];
Xptr = &Xmat[j*ldx];
while (1) { /* Loop until stopping criterion is satisfied. */
/* Compute residual R = B - op(A) * X,
where op(A) = A, A**T, or A**H, depending on TRANS. */
#ifdef _CRAY
CCOPY(&A->nrow, Bptr, &ione, work, &ione);
#else
ccopy_(&A->nrow, Bptr, &ione, work, &ione);
#endif
sp_cgemv(transc, ndone, A, Xptr, ione, done, work, ione);
/* Compute componentwise relative backward error from formula
max(i) ( abs(R(i)) / ( abs(op(A))*abs(X) + abs(B) )(i) )
where abs(Z) is the componentwise absolute value of the matrix
or vector Z. If the i-th component of the denominator is less
than SAFE2, then SAFE1 is added to the i-th component of the
numerator before dividing. */
for (i = 0; i < A->nrow; ++i) rwork[i] = c_abs1( &Bptr[i] );
/* Compute abs(op(A))*abs(X) + abs(B). */
if (notran) {
for (k = 0; k < A->ncol; ++k) {
xk = c_abs1( &Xptr[k] );
for (i = Astore->colptr[k]; i < Astore->colptr[k+1]; ++i)
rwork[Astore->rowind[i]] += c_abs1(&Aval[i]) * xk;
}
} else {
for (k = 0; k < A->ncol; ++k) {
s = 0.;
for (i = Astore->colptr[k]; i < Astore->colptr[k+1]; ++i) {
irow = Astore->rowind[i];
s += c_abs1(&Aval[i]) * c_abs1(&Xptr[irow]);
}
rwork[k] += s;
}
}
s = 0.;
for (i = 0; i < A->nrow; ++i) {
if (rwork[i] > safe2) {
s = SUPERLU_MAX( s, c_abs1(&work[i]) / rwork[i] );
} else if ( rwork[i] != 0.0 ) {
s = SUPERLU_MAX( s, (c_abs1(&work[i]) + safe1) / rwork[i] );
}
/* If rwork[i] is exactly 0.0, then we know the true
residual also must be exactly 0.0. */
}
berr[j] = s;
/* Test stopping criterion. Continue iterating if
1) The residual BERR(J) is larger than machine epsilon, and
2) BERR(J) decreased by at least a factor of 2 during the
last iteration, and
3) At most ITMAX iterations tried. */
if (berr[j] > eps && berr[j] * 2. <= lstres && count < ITMAX) {
/* Update solution and try again. */
cgstrs (trans, L, U, perm_c, perm_r, &Bjcol, stat, info);
#ifdef _CRAY
CAXPY(&A->nrow, &done, work, &ione,
&Xmat[j*ldx], &ione);
#else
caxpy_(&A->nrow, &done, work, &ione,
&Xmat[j*ldx], &ione);
#endif
lstres = berr[j];
++count;
} else {
break;
}
} /* end while */
stat->RefineSteps = count;
/* Bound error from formula:
norm(X - XTRUE) / norm(X) .le. FERR = norm( abs(inv(op(A)))*
( abs(R) + NZ*EPS*( abs(op(A))*abs(X)+abs(B) ))) / norm(X)
where
norm(Z) is the magnitude of the largest component of Z
inv(op(A)) is the inverse of op(A)
abs(Z) is the componentwise absolute value of the matrix or
vector Z
NZ is the maximum number of nonzeros in any row of A, plus 1
EPS is machine epsilon
The i-th component of abs(R)+NZ*EPS*(abs(op(A))*abs(X)+abs(B))
is incremented by SAFE1 if the i-th component of
abs(op(A))*abs(X) + abs(B) is less than SAFE2.
Use CLACON2 to estimate the infinity-norm of the matrix
inv(op(A)) * diag(W),
where W = abs(R) + NZ*EPS*( abs(op(A))*abs(X)+abs(B) ))) */
for (i = 0; i < A->nrow; ++i) rwork[i] = c_abs1( &Bptr[i] );
/* Compute abs(op(A))*abs(X) + abs(B). */
if ( notran ) {
for (k = 0; k < A->ncol; ++k) {
xk = c_abs1( &Xptr[k] );
for (i = Astore->colptr[k]; i < Astore->colptr[k+1]; ++i)
rwork[Astore->rowind[i]] += c_abs1(&Aval[i]) * xk;
}
} else {
for (k = 0; k < A->ncol; ++k) {
s = 0.;
for (i = Astore->colptr[k]; i < Astore->colptr[k+1]; ++i) {
irow = Astore->rowind[i];
xk = c_abs1( &Xptr[irow] );
s += c_abs1(&Aval[i]) * xk;
}
rwork[k] += s;
}
}
for (i = 0; i < A->nrow; ++i)
if (rwork[i] > safe2)
rwork[i] = c_abs(&work[i]) + (iwork[i]+1)*eps*rwork[i];
else
rwork[i] = c_abs(&work[i])+(iwork[i]+1)*eps*rwork[i]+safe1;
kase = 0;
do {
clacon2_(&A->nrow, &work[A->nrow], work, &ferr[j], &kase, isave);
if (kase == 0) break;
if (kase == 1) {
/* Multiply by diag(W)*inv(op(A)**T)*(diag(C) or diag(R)). */
if ( notran && colequ )
for (i = 0; i < A->ncol; ++i) {
cs_mult(&work[i], &work[i], C[i]);
}
else if ( !notran && rowequ )
for (i = 0; i < A->nrow; ++i) {
cs_mult(&work[i], &work[i], R[i]);
}
cgstrs (transt, L, U, perm_c, perm_r, &Bjcol, stat, info);
for (i = 0; i < A->nrow; ++i) {
cs_mult(&work[i], &work[i], rwork[i]);
}
} else {
/* Multiply by (diag(C) or diag(R))*inv(op(A))*diag(W). */
for (i = 0; i < A->nrow; ++i) {
cs_mult(&work[i], &work[i], rwork[i]);
}
cgstrs (trans, L, U, perm_c, perm_r, &Bjcol, stat, info);
if ( notran && colequ )
for (i = 0; i < A->ncol; ++i) {
cs_mult(&work[i], &work[i], C[i]);
}
else if ( !notran && rowequ )
for (i = 0; i < A->ncol; ++i) {
cs_mult(&work[i], &work[i], R[i]);
}
}
} while ( kase != 0 );
/* Normalize error. */
lstres = 0.;
if ( notran && colequ ) {
for (i = 0; i < A->nrow; ++i)
lstres = SUPERLU_MAX( lstres, C[i] * c_abs1( &Xptr[i]) );
} else if ( !notran && rowequ ) {
for (i = 0; i < A->nrow; ++i)
lstres = SUPERLU_MAX( lstres, R[i] * c_abs1( &Xptr[i]) );
} else {
for (i = 0; i < A->nrow; ++i)
lstres = SUPERLU_MAX( lstres, c_abs1( &Xptr[i]) );
}
if ( lstres != 0. )
ferr[j] /= lstres;
} /* for each RHS j ... */
SUPERLU_FREE(work);
SUPERLU_FREE(rwork);
SUPERLU_FREE(iwork);
SUPERLU_FREE(Bjcol.Store);
return;
} /* cgsrfs */
int cgst01(int m, int n, SuperMatrix *A, SuperMatrix *L,
SuperMatrix *U, int *perm_c, int *perm_r, float *resid)
{
/*
Purpose
=======
CGST01 reconstructs a matrix A from its L*U factorization and
computes the residual
norm(L*U - A) / ( N * norm(A) * EPS ),
where EPS is the machine epsilon.
Arguments
==========
M (input) INT
The number of rows of the matrix A. M >= 0.
N (input) INT
The number of columns of the matrix A. N >= 0.
A (input) SuperMatrix *, dimension (A->nrow, A->ncol)
The original M x N matrix A.
L (input) SuperMatrix *, dimension (L->nrow, L->ncol)
The factor matrix L.
U (input) SuperMatrix *, dimension (U->nrow, U->ncol)
The factor matrix U.
perm_c (input) INT array, dimension (N)
The column permutation from CGSTRF.
perm_r (input) INT array, dimension (M)
The pivot indices from CGSTRF.
RESID (output) FLOAT*
norm(L*U - A) / ( N * norm(A) * EPS )
=====================================================================
*/
/* Local variables */
complex zero = {0.0, 0.0};
int i, j, k, arow, lptr,isub, urow, superno, fsupc, u_part;
complex utemp, comp_temp;
float anorm, tnorm, cnorm;
float eps;
complex *work;
SCformat *Lstore;
NCformat *Astore, *Ustore;
complex *Aval, *Lval, *Uval;
int *colbeg, *colend;
/* Function prototypes */
extern float clangs(char *, SuperMatrix *);
/* Quick exit if M = 0 or N = 0. */
if (m <= 0 || n <= 0) {
*resid = 0.f;
return 0;
}
work = (complex *)complexCalloc(m);
Astore = A->Store;
Aval = Astore->nzval;
Lstore = L->Store;
Lval = Lstore->nzval;
Ustore = U->Store;
Uval = Ustore->nzval;
colbeg = intMalloc(n);
colend = intMalloc(n);
for (i = 0; i < n; i++) {
colbeg[perm_c[i]] = Astore->colptr[i];
colend[perm_c[i]] = Astore->colptr[i+1];
}
/* Determine EPS and the norm of A. */
eps = smach("Epsilon");
anorm = clangs("1", A);
cnorm = 0.;
/* Compute the product L*U, one column at a time */
for (k = 0; k < n; ++k) {
/* The U part outside the rectangular supernode */
for (i = U_NZ_START(k); i < U_NZ_START(k+1); ++i) {
urow = U_SUB(i);
utemp = Uval[i];
superno = Lstore->col_to_sup[urow];
fsupc = L_FST_SUPC(superno);
u_part = urow - fsupc + 1;
lptr = L_SUB_START(fsupc) + u_part;
work[L_SUB(lptr-1)].r -= utemp.r;
work[L_SUB(lptr-1)].i -= utemp.i;
for (j = L_NZ_START(urow) + u_part; j < L_NZ_START(urow+1); ++j) {
isub = L_SUB(lptr);
cc_mult(&comp_temp, &utemp, &Lval[j]);
c_sub(&work[isub], &work[isub], &comp_temp);
++lptr;
}
}
/* The U part inside the rectangular supernode */
superno = Lstore->col_to_sup[k];
fsupc = L_FST_SUPC(superno);
urow = L_NZ_START(k);
for (i = fsupc; i <= k; ++i) {
utemp = Lval[urow++];
u_part = i - fsupc + 1;
lptr = L_SUB_START(fsupc) + u_part;
work[L_SUB(lptr-1)].r -= utemp.r;
work[L_SUB(lptr-1)].i -= utemp.i;
for (j = L_NZ_START(i)+u_part; j < L_NZ_START(i+1); ++j) {
isub = L_SUB(lptr);
cc_mult(&comp_temp, &utemp, &Lval[j]);
c_sub(&work[isub], &work[isub], &comp_temp);
++lptr;
}
}
/* Now compute A[k] - (L*U)[k] (Both matrices may be permuted.) */
for (i = colbeg[k]; i < colend[k]; ++i) {
arow = Astore->rowind[i];
work[perm_r[arow]].r += Aval[i].r;
work[perm_r[arow]].i += Aval[i].i;
}
/* Now compute the 1-norm of the column vector work */
tnorm = 0.;
for (i = 0; i < m; ++i) {
tnorm += fabs(work[i].r) + fabs(work[i].i);
work[i] = zero;
}
cnorm = SUPERLU_MAX(tnorm, cnorm);
}
*resid = cnorm;
if (anorm <= 0.f) {
if (*resid != 0.f) {
*resid = 1.f / eps;
}
} else {
*resid = *resid / (float) n / anorm / eps;
}
SUPERLU_FREE(work);
SUPERLU_FREE(colbeg);
SUPERLU_FREE(colend);
return 0;
/* End of CGST01 */
} /* cgst01_ */
void
cgssvx(superlu_options_t *options, SuperMatrix *A, int *perm_c, int *perm_r,
int *etree, char *equed, float *R, float *C,
SuperMatrix *L, SuperMatrix *U, void *work, int lwork,
SuperMatrix *B, SuperMatrix *X, float *recip_pivot_growth,
float *rcond, float *ferr, float *berr,
GlobalLU_t *Glu, mem_usage_t *mem_usage, SuperLUStat_t *stat, int *info )
{
DNformat *Bstore, *Xstore;
complex *Bmat, *Xmat;
int ldb, ldx, nrhs;
SuperMatrix *AA;/* A in SLU_NC format used by the factorization routine.*/
SuperMatrix AC; /* Matrix postmultiplied by Pc */
int colequ, equil, nofact, notran, rowequ, permc_spec;
trans_t trant;
char norm[1];
int i, j, info1;
float amax, anorm, bignum, smlnum, colcnd, rowcnd, rcmax, rcmin;
int relax, panel_size;
float diag_pivot_thresh;
double t0; /* temporary time */
double *utime;
/* External functions */
extern float clangs(char *, SuperMatrix *);
Bstore = B->Store;
Xstore = X->Store;
Bmat = Bstore->nzval;
Xmat = Xstore->nzval;
ldb = Bstore->lda;
ldx = Xstore->lda;
nrhs = B->ncol;
*info = 0;
nofact = (options->Fact != FACTORED);
equil = (options->Equil == YES);
notran = (options->Trans == NOTRANS);
if ( nofact ) {
*(unsigned char *)equed = 'N';
rowequ = FALSE;
colequ = FALSE;
} else {
rowequ = strncmp(equed, "R", 1)==0 || strncmp(equed, "B", 1)==0;
colequ = strncmp(equed, "C", 1)==0 || strncmp(equed, "B", 1)==0;
smlnum = smach("Safe minimum"); /* lamch_("Safe minimum"); */
bignum = 1. / smlnum;
}
#if 0
printf("dgssvx: Fact=%4d, Trans=%4d, equed=%c\n",
options->Fact, options->Trans, *equed);
#endif
/* Test the input parameters */
if (options->Fact != DOFACT && options->Fact != SamePattern &&
options->Fact != SamePattern_SameRowPerm &&
options->Fact != FACTORED &&
options->Trans != NOTRANS && options->Trans != TRANS &&
options->Trans != CONJ &&
options->Equil != NO && options->Equil != YES)
*info = -1;
else if ( A->nrow != A->ncol || A->nrow < 0 ||
(A->Stype != SLU_NC && A->Stype != SLU_NR) ||
A->Dtype != SLU_C || A->Mtype != SLU_GE )
*info = -2;
else if ( options->Fact == FACTORED &&
!(rowequ || colequ || strncmp(equed, "N", 1)==0) )
*info = -6;
else {
if (rowequ) {
rcmin = bignum;
rcmax = 0.;
for (j = 0; j < A->nrow; ++j) {
rcmin = SUPERLU_MIN(rcmin, R[j]);
rcmax = SUPERLU_MAX(rcmax, R[j]);
}
if (rcmin <= 0.) *info = -7;
else if ( A->nrow > 0)
rowcnd = SUPERLU_MAX(rcmin,smlnum) / SUPERLU_MIN(rcmax,bignum);
else rowcnd = 1.;
}
if (colequ && *info == 0) {
rcmin = bignum;
rcmax = 0.;
for (j = 0; j < A->nrow; ++j) {
rcmin = SUPERLU_MIN(rcmin, C[j]);
rcmax = SUPERLU_MAX(rcmax, C[j]);
}
if (rcmin <= 0.) *info = -8;
else if (A->nrow > 0)
colcnd = SUPERLU_MAX(rcmin,smlnum) / SUPERLU_MIN(rcmax,bignum);
else colcnd = 1.;
}
if (*info == 0) {
if ( lwork < -1 ) *info = -12;
else if ( B->ncol < 0 ) *info = -13;
else if ( B->ncol > 0 ) { /* no checking if B->ncol=0 */
if ( Bstore->lda < SUPERLU_MAX(0, A->nrow) ||
B->Stype != SLU_DN || B->Dtype != SLU_C ||
B->Mtype != SLU_GE )
*info = -13;
}
if ( X->ncol < 0 ) *info = -14;
else if ( X->ncol > 0 ) { /* no checking if X->ncol=0 */
if ( Xstore->lda < SUPERLU_MAX(0, A->nrow) ||
(B->ncol != 0 && B->ncol != X->ncol) ||
X->Stype != SLU_DN ||
X->Dtype != SLU_C || X->Mtype != SLU_GE )
*info = -14;
}
}
}
if (*info != 0) {
i = -(*info);
input_error("cgssvx", &i);
return;
}
/* Initialization for factor parameters */
panel_size = sp_ienv(1);
relax = sp_ienv(2);
diag_pivot_thresh = options->DiagPivotThresh;
utime = stat->utime;
/* Convert A to SLU_NC format when necessary. */
if ( A->Stype == SLU_NR ) {
NRformat *Astore = A->Store;
AA = (SuperMatrix *) SUPERLU_MALLOC( sizeof(SuperMatrix) );
cCreate_CompCol_Matrix(AA, A->ncol, A->nrow, Astore->nnz,
Astore->nzval, Astore->colind, Astore->rowptr,
SLU_NC, A->Dtype, A->Mtype);
if ( notran ) { /* Reverse the transpose argument. */
trant = TRANS;
notran = 0;
} else {
trant = NOTRANS;
notran = 1;
}
} else { /* A->Stype == SLU_NC */
trant = options->Trans;
AA = A;
}
if ( nofact && equil ) {
t0 = SuperLU_timer_();
/* Compute row and column scalings to equilibrate the matrix A. */
cgsequ(AA, R, C, &rowcnd, &colcnd, &amax, &info1);
if ( info1 == 0 ) {
/* Equilibrate matrix A. */
claqgs(AA, R, C, rowcnd, colcnd, amax, equed);
rowequ = strncmp(equed, "R", 1)==0 || strncmp(equed, "B", 1)==0;
colequ = strncmp(equed, "C", 1)==0 || strncmp(equed, "B", 1)==0;
}
utime[EQUIL] = SuperLU_timer_() - t0;
}
if ( nofact ) {
t0 = SuperLU_timer_();
/*
* Gnet column permutation vector perm_c[], according to permc_spec:
* permc_spec = NATURAL: natural ordering
* permc_spec = MMD_AT_PLUS_A: minimum degree on structure of A'+A
* permc_spec = MMD_ATA: minimum degree on structure of A'*A
* permc_spec = COLAMD: approximate minimum degree column ordering
* permc_spec = MY_PERMC: the ordering already supplied in perm_c[]
*/
permc_spec = options->ColPerm;
if ( permc_spec != MY_PERMC && options->Fact == DOFACT )
get_perm_c(permc_spec, AA, perm_c);
utime[COLPERM] = SuperLU_timer_() - t0;
t0 = SuperLU_timer_();
sp_preorder(options, AA, perm_c, etree, &AC);
utime[ETREE] = SuperLU_timer_() - t0;
/* printf("Factor PA = LU ... relax %d\tw %d\tmaxsuper %d\trowblk %d\n",
relax, panel_size, sp_ienv(3), sp_ienv(4));
fflush(stdout); */
/* Compute the LU factorization of A*Pc. */
t0 = SuperLU_timer_();
cgstrf(options, &AC, relax, panel_size, etree,
work, lwork, perm_c, perm_r, L, U, Glu, stat, info);
utime[FACT] = SuperLU_timer_() - t0;
if ( lwork == -1 ) {
mem_usage->total_needed = *info - A->ncol;
return;
}
}
if ( *info > 0 ) {
if ( *info <= A->ncol ) {
/* Compute the reciprocal pivot growth factor of the leading
rank-deficient (*info) columns of A. */
*recip_pivot_growth = cPivotGrowth(*info, AA, perm_c, L, U);
}
return;
}
/* *info == 0 at this point. */
if ( options->PivotGrowth ) {
/* Compute the reciprocal pivot growth factor *recip_pivot_growth. */
*recip_pivot_growth = cPivotGrowth(A->ncol, AA, perm_c, L, U);
}
if ( options->ConditionNumber ) {
/* Estimate the reciprocal of the condition number of A. */
t0 = SuperLU_timer_();
if ( notran ) {
*(unsigned char *)norm = '1';
} else {
*(unsigned char *)norm = 'I';
}
anorm = clangs(norm, AA);
cgscon(norm, L, U, anorm, rcond, stat, &info1);
utime[RCOND] = SuperLU_timer_() - t0;
}
if ( nrhs > 0 ) {
/* Scale the right hand side if equilibration was performed. */
if ( notran ) {
if ( rowequ ) {
for (j = 0; j < nrhs; ++j)
for (i = 0; i < A->nrow; ++i)
cs_mult(&Bmat[i+j*ldb], &Bmat[i+j*ldb], R[i]);
}
} else if ( colequ ) {
for (j = 0; j < nrhs; ++j)
for (i = 0; i < A->nrow; ++i)
cs_mult(&Bmat[i+j*ldb], &Bmat[i+j*ldb], C[i]);
}
/* Compute the solution matrix X. */
for (j = 0; j < nrhs; j++) /* Save a copy of the right hand sides */
for (i = 0; i < B->nrow; i++)
Xmat[i + j*ldx] = Bmat[i + j*ldb];
t0 = SuperLU_timer_();
cgstrs (trant, L, U, perm_c, perm_r, X, stat, &info1);
utime[SOLVE] = SuperLU_timer_() - t0;
/* Use iterative refinement to improve the computed solution and compute
error bounds and backward error estimates for it. */
t0 = SuperLU_timer_();
if ( options->IterRefine != NOREFINE ) {
cgsrfs(trant, AA, L, U, perm_c, perm_r, equed, R, C, B,
X, ferr, berr, stat, &info1);
} else {
for (j = 0; j < nrhs; ++j) ferr[j] = berr[j] = 1.0;
}
utime[REFINE] = SuperLU_timer_() - t0;
/* Transform the solution matrix X to a solution of the original system. */
if ( notran ) {
if ( colequ ) {
for (j = 0; j < nrhs; ++j)
for (i = 0; i < A->nrow; ++i)
cs_mult(&Xmat[i+j*ldx], &Xmat[i+j*ldx], C[i]);
}
} else if ( rowequ ) {
for (j = 0; j < nrhs; ++j)
for (i = 0; i < A->nrow; ++i)
cs_mult(&Xmat[i+j*ldx], &Xmat[i+j*ldx], R[i]);
}
} /* end if nrhs > 0 */
if ( options->ConditionNumber ) {
/* Set INFO = A->ncol+1 if the matrix is singular to working precision. */
/*if ( *rcond < slamch_("E") ) *info = A->ncol + 1;*/
if ( *rcond < smach("E") ) *info = A->ncol + 1;
}
if ( nofact ) {
cQuerySpace(L, U, mem_usage);
Destroy_CompCol_Permuted(&AC);
}
if ( A->Stype == SLU_NR ) {
Destroy_SuperMatrix_Store(AA);
SUPERLU_FREE(AA);
}
}
/* Subroutine */ int slartg_slu(real *f, real *g, real *cs, real *sn, real *r)
{
/* -- LAPACK auxiliary routine (version 2.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
September 30, 1994
Purpose
=======
SLARTG generate a plane rotation so that
[ CS SN ] . [ F ] = [ R ] where CS**2 + SN**2 = 1.
[ -SN CS ] [ G ] [ 0 ]
This is a slower, more accurate version of the BLAS1 routine SROTG,
with the following other differences:
F and G are unchanged on return.
If G=0, then CS=1 and SN=0.
If F=0 and (G .ne. 0), then CS=0 and SN=1 without doing any
floating point operations (saves work in SBDSQR when
there are zeros on the diagonal).
If F exceeds G in magnitude, CS will be positive.
Arguments
=========
F (input) REAL
The first component of vector to be rotated.
G (input) REAL
The second component of vector to be rotated.
CS (output) REAL
The cosine of the rotation.
SN (output) REAL
The sine of the rotation.
R (output) REAL
The nonzero component of the rotated vector.
=====================================================================
*/
/* Initialized data */
static logical first = TRUE_;
/* System generated locals */
integer i__1;
real r__1, r__2;
/* Builtin functions */
double log(doublereal), pow_ri(real *, integer *), sqrt(doublereal);
/* Local variables */
static integer i;
static real scale;
static integer count;
static real f1, g1, safmn2, safmx2;
extern float smach(char *);
static real safmin, eps;
if (first) {
first = FALSE_;
safmin = smach("S");
eps = smach("E");
r__1 = smach("B");
i__1 = (integer) (log(safmin / eps) / log(smach("B")) / 2.f);
safmn2 = pow_ri(&r__1, &i__1);
safmx2 = 1.f / safmn2;
}
if (*g == 0.f) {
*cs = 1.f;
*sn = 0.f;
*r = *f;
} else if (*f == 0.f) {
*cs = 0.f;
*sn = 1.f;
*r = *g;
} else {
f1 = *f;
g1 = *g;
/* Computing MAX */
r__1 = dabs(f1), r__2 = dabs(g1);
scale = dmax(r__1,r__2);
if (scale >= safmx2) {
count = 0;
L10:
++count;
f1 *= safmn2;
g1 *= safmn2;
/* Computing MAX */
r__1 = dabs(f1), r__2 = dabs(g1);
scale = dmax(r__1,r__2);
if (scale >= safmx2) {
goto L10;
}
/* Computing 2nd power */
r__1 = f1;
/* Computing 2nd power */
r__2 = g1;
*r = sqrt(r__1 * r__1 + r__2 * r__2);
*cs = f1 / *r;
*sn = g1 / *r;
i__1 = count;
for (i = 1; i <= count; ++i) {
*r *= safmx2;
/* L20: */
}
} else if (scale <= safmn2) {
count = 0;
L30:
++count;
f1 *= safmx2;
g1 *= safmx2;
/* Computing MAX */
r__1 = dabs(f1), r__2 = dabs(g1);
scale = dmax(r__1,r__2);
if (scale <= safmn2) {
goto L30;
}
/* Computing 2nd power */
r__1 = f1;
/* Computing 2nd power */
r__2 = g1;
*r = sqrt(r__1 * r__1 + r__2 * r__2);
*cs = f1 / *r;
*sn = g1 / *r;
i__1 = count;
for (i = 1; i <= count; ++i) {
*r *= safmn2;
/* L40: */
}
} else {
/* Computing 2nd power */
r__1 = f1;
/* Computing 2nd power */
r__2 = g1;
*r = sqrt(r__1 * r__1 + r__2 * r__2);
*cs = f1 / *r;
*sn = g1 / *r;
}
if (dabs(*f) > dabs(*g) && *cs < 0.f) {
*cs = -(doublereal)(*cs);
*sn = -(doublereal)(*sn);
*r = -(doublereal)(*r);
}
}
return 0;
/* End of SLARTG */
} /* slartg_slu */
void
cgsisx(superlu_options_t *options, SuperMatrix *A, int *perm_c, int *perm_r,
int *etree, char *equed, float *R, float *C,
SuperMatrix *L, SuperMatrix *U, void *work, int lwork,
SuperMatrix *B, SuperMatrix *X,
float *recip_pivot_growth, float *rcond,
GlobalLU_t *Glu, mem_usage_t *mem_usage, SuperLUStat_t *stat, int *info)
{
DNformat *Bstore, *Xstore;
complex *Bmat, *Xmat;
int ldb, ldx, nrhs, n;
SuperMatrix *AA;/* A in SLU_NC format used by the factorization routine.*/
SuperMatrix AC; /* Matrix postmultiplied by Pc */
int colequ, equil, nofact, notran, rowequ, permc_spec, mc64;
trans_t trant;
char norm[1];
int i, j, info1;
float amax, anorm, bignum, smlnum, colcnd, rowcnd, rcmax, rcmin;
int relax, panel_size;
float diag_pivot_thresh;
double t0; /* temporary time */
double *utime;
int *perm = NULL; /* permutation returned from MC64 */
/* External functions */
extern float clangs(char *, SuperMatrix *);
Bstore = B->Store;
Xstore = X->Store;
Bmat = Bstore->nzval;
Xmat = Xstore->nzval;
ldb = Bstore->lda;
ldx = Xstore->lda;
nrhs = B->ncol;
n = B->nrow;
*info = 0;
nofact = (options->Fact != FACTORED);
equil = (options->Equil == YES);
notran = (options->Trans == NOTRANS);
mc64 = (options->RowPerm == LargeDiag);
if ( nofact ) {
*(unsigned char *)equed = 'N';
rowequ = FALSE;
colequ = FALSE;
} else {
rowequ = lsame_(equed, "R") || lsame_(equed, "B");
colequ = lsame_(equed, "C") || lsame_(equed, "B");
smlnum = smach("Safe minimum"); /* lamch_("Safe minimum"); */
bignum = 1. / smlnum;
}
/* Test the input parameters */
if (options->Fact != DOFACT && options->Fact != SamePattern &&
options->Fact != SamePattern_SameRowPerm &&
options->Fact != FACTORED &&
options->Trans != NOTRANS && options->Trans != TRANS &&
options->Trans != CONJ &&
options->Equil != NO && options->Equil != YES)
*info = -1;
else if ( A->nrow != A->ncol || A->nrow < 0 ||
(A->Stype != SLU_NC && A->Stype != SLU_NR) ||
A->Dtype != SLU_C || A->Mtype != SLU_GE )
*info = -2;
else if (options->Fact == FACTORED &&
!(rowequ || colequ || lsame_(equed, "N")))
*info = -6;
else {
if (rowequ) {
rcmin = bignum;
rcmax = 0.;
for (j = 0; j < A->nrow; ++j) {
rcmin = SUPERLU_MIN(rcmin, R[j]);
rcmax = SUPERLU_MAX(rcmax, R[j]);
}
if (rcmin <= 0.) *info = -7;
else if ( A->nrow > 0)
rowcnd = SUPERLU_MAX(rcmin,smlnum) / SUPERLU_MIN(rcmax,bignum);
else rowcnd = 1.;
}
if (colequ && *info == 0) {
rcmin = bignum;
rcmax = 0.;
for (j = 0; j < A->nrow; ++j) {
rcmin = SUPERLU_MIN(rcmin, C[j]);
rcmax = SUPERLU_MAX(rcmax, C[j]);
}
if (rcmin <= 0.) *info = -8;
else if (A->nrow > 0)
colcnd = SUPERLU_MAX(rcmin,smlnum) / SUPERLU_MIN(rcmax,bignum);
else colcnd = 1.;
}
if (*info == 0) {
if ( lwork < -1 ) *info = -12;
else if ( B->ncol < 0 || Bstore->lda < SUPERLU_MAX(0, A->nrow) ||
B->Stype != SLU_DN || B->Dtype != SLU_C ||
B->Mtype != SLU_GE )
*info = -13;
else if ( X->ncol < 0 || Xstore->lda < SUPERLU_MAX(0, A->nrow) ||
(B->ncol != 0 && B->ncol != X->ncol) ||
X->Stype != SLU_DN ||
X->Dtype != SLU_C || X->Mtype != SLU_GE )
*info = -14;
}
}
if (*info != 0) {
i = -(*info);
input_error("cgsisx", &i);
return;
}
/* Initialization for factor parameters */
panel_size = sp_ienv(1);
relax = sp_ienv(2);
diag_pivot_thresh = options->DiagPivotThresh;
utime = stat->utime;
/* Convert A to SLU_NC format when necessary. */
if ( A->Stype == SLU_NR ) {
NRformat *Astore = A->Store;
AA = (SuperMatrix *) SUPERLU_MALLOC( sizeof(SuperMatrix) );
cCreate_CompCol_Matrix(AA, A->ncol, A->nrow, Astore->nnz,
Astore->nzval, Astore->colind, Astore->rowptr,
SLU_NC, A->Dtype, A->Mtype);
if ( notran ) { /* Reverse the transpose argument. */
trant = TRANS;
notran = 0;
} else {
trant = NOTRANS;
notran = 1;
}
} else { /* A->Stype == SLU_NC */
trant = options->Trans;
AA = A;
}
if ( nofact ) {
register int i, j;
NCformat *Astore = AA->Store;
int nnz = Astore->nnz;
int *colptr = Astore->colptr;
int *rowind = Astore->rowind;
complex *nzval = (complex *)Astore->nzval;
if ( mc64 ) {
t0 = SuperLU_timer_();
if ((perm = intMalloc(n)) == NULL)
ABORT("SUPERLU_MALLOC fails for perm[]");
info1 = cldperm(5, n, nnz, colptr, rowind, nzval, perm, R, C);
if (info1 != 0) { /* MC64 fails, call cgsequ() later */
mc64 = 0;
SUPERLU_FREE(perm);
perm = NULL;
} else {
if ( equil ) {
rowequ = colequ = 1;
for (i = 0; i < n; i++) {
R[i] = exp(R[i]);
C[i] = exp(C[i]);
}
/* scale the matrix */
for (j = 0; j < n; j++) {
for (i = colptr[j]; i < colptr[j + 1]; i++) {
cs_mult(&nzval[i], &nzval[i], R[rowind[i]] * C[j]);
}
}
*equed = 'B';
}
/* permute the matrix */
for (j = 0; j < n; j++) {
for (i = colptr[j]; i < colptr[j + 1]; i++) {
/*nzval[i] *= R[rowind[i]] * C[j];*/
rowind[i] = perm[rowind[i]];
}
}
}
utime[EQUIL] = SuperLU_timer_() - t0;
}
if ( !mc64 & equil ) { /* Only perform equilibration, no row perm */
t0 = SuperLU_timer_();
/* Compute row and column scalings to equilibrate the matrix A. */
cgsequ(AA, R, C, &rowcnd, &colcnd, &amax, &info1);
if ( info1 == 0 ) {
/* Equilibrate matrix A. */
claqgs(AA, R, C, rowcnd, colcnd, amax, equed);
rowequ = lsame_(equed, "R") || lsame_(equed, "B");
colequ = lsame_(equed, "C") || lsame_(equed, "B");
}
utime[EQUIL] = SuperLU_timer_() - t0;
}
}
if ( nofact ) {
t0 = SuperLU_timer_();
/*
* Gnet column permutation vector perm_c[], according to permc_spec:
* permc_spec = NATURAL: natural ordering
* permc_spec = MMD_AT_PLUS_A: minimum degree on structure of A'+A
* permc_spec = MMD_ATA: minimum degree on structure of A'*A
* permc_spec = COLAMD: approximate minimum degree column ordering
* permc_spec = MY_PERMC: the ordering already supplied in perm_c[]
*/
permc_spec = options->ColPerm;
if ( permc_spec != MY_PERMC && options->Fact == DOFACT )
get_perm_c(permc_spec, AA, perm_c);
utime[COLPERM] = SuperLU_timer_() - t0;
t0 = SuperLU_timer_();
sp_preorder(options, AA, perm_c, etree, &AC);
utime[ETREE] = SuperLU_timer_() - t0;
/* Compute the LU factorization of A*Pc. */
t0 = SuperLU_timer_();
cgsitrf(options, &AC, relax, panel_size, etree, work, lwork,
perm_c, perm_r, L, U, Glu, stat, info);
utime[FACT] = SuperLU_timer_() - t0;
if ( lwork == -1 ) {
mem_usage->total_needed = *info - A->ncol;
return;
}
if ( mc64 ) { /* Fold MC64's perm[] into perm_r[]. */
NCformat *Astore = AA->Store;
int nnz = Astore->nnz, *rowind = Astore->rowind;
int *perm_tmp, *iperm;
if ((perm_tmp = intMalloc(2*n)) == NULL)
ABORT("SUPERLU_MALLOC fails for perm_tmp[]");
iperm = perm_tmp + n;
for (i = 0; i < n; ++i) perm_tmp[i] = perm_r[perm[i]];
for (i = 0; i < n; ++i) {
perm_r[i] = perm_tmp[i];
iperm[perm[i]] = i;
}
/* Restore A's original row indices. */
for (i = 0; i < nnz; ++i) rowind[i] = iperm[rowind[i]];
SUPERLU_FREE(perm); /* MC64 permutation */
SUPERLU_FREE(perm_tmp);
}
}
if ( options->PivotGrowth ) {
if ( *info > 0 ) return;
/* Compute the reciprocal pivot growth factor *recip_pivot_growth. */
*recip_pivot_growth = cPivotGrowth(A->ncol, AA, perm_c, L, U);
}
if ( options->ConditionNumber ) {
/* Estimate the reciprocal of the condition number of A. */
t0 = SuperLU_timer_();
if ( notran ) {
*(unsigned char *)norm = '1';
} else {
*(unsigned char *)norm = 'I';
}
anorm = clangs(norm, AA);
cgscon(norm, L, U, anorm, rcond, stat, &info1);
utime[RCOND] = SuperLU_timer_() - t0;
}
if ( nrhs > 0 ) { /* Solve the system */
complex *rhs_work;
/* Scale and permute the right-hand side if equilibration
and permutation from MC64 were performed. */
if ( notran ) {
if ( rowequ ) {
for (j = 0; j < nrhs; ++j)
for (i = 0; i < n; ++i)
cs_mult(&Bmat[i+j*ldb], &Bmat[i+j*ldb], R[i]);
}
} else if ( colequ ) {
for (j = 0; j < nrhs; ++j)
for (i = 0; i < n; ++i) {
cs_mult(&Bmat[i+j*ldb], &Bmat[i+j*ldb], C[i]);
}
}
/* Compute the solution matrix X. */
for (j = 0; j < nrhs; j++) /* Save a copy of the right hand sides */
for (i = 0; i < B->nrow; i++)
Xmat[i + j*ldx] = Bmat[i + j*ldb];
t0 = SuperLU_timer_();
cgstrs (trant, L, U, perm_c, perm_r, X, stat, &info1);
utime[SOLVE] = SuperLU_timer_() - t0;
/* Transform the solution matrix X to a solution of the original
system. */
if ( notran ) {
if ( colequ ) {
for (j = 0; j < nrhs; ++j)
for (i = 0; i < n; ++i) {
cs_mult(&Xmat[i+j*ldx], &Xmat[i+j*ldx], C[i]);
}
}
} else { /* transposed system */
if ( rowequ ) {
for (j = 0; j < nrhs; ++j)
for (i = 0; i < A->nrow; ++i) {
cs_mult(&Xmat[i+j*ldx], &Xmat[i+j*ldx], R[i]);
}
}
}
} /* end if nrhs > 0 */
if ( options->ConditionNumber ) {
/* The matrix is singular to working precision. */
/* if ( *rcond < slamch_("E") && *info == 0) *info = A->ncol + 1; */
if ( *rcond < smach("E") && *info == 0) *info = A->ncol + 1;
}
if ( nofact ) {
ilu_cQuerySpace(L, U, mem_usage);
Destroy_CompCol_Permuted(&AC);
}
if ( A->Stype == SLU_NR ) {
Destroy_SuperMatrix_Store(AA);
SUPERLU_FREE(AA);
}
}
void
claqgs(SuperMatrix *A, float *r, float *c,
float rowcnd, float colcnd, float amax, char *equed)
{
#define THRESH (0.1)
/* Local variables */
NCformat *Astore;
complex *Aval;
int i, j, irow;
float large, small, cj;
float temp;
/* Quick return if possible */
if (A->nrow <= 0 || A->ncol <= 0) {
*(unsigned char *)equed = 'N';
return;
}
Astore = A->Store;
Aval = Astore->nzval;
/* Initialize LARGE and SMALL. */
small = smach("Safe minimum") / smach("Precision");
large = 1. / small;
if (rowcnd >= THRESH && amax >= small && amax <= large) {
if (colcnd >= THRESH)
*(unsigned char *)equed = 'N';
else {
/* Column scaling */
for (j = 0; j < A->ncol; ++j) {
cj = c[j];
for (i = Astore->colptr[j]; i < Astore->colptr[j+1]; ++i) {
cs_mult(&Aval[i], &Aval[i], cj);
}
}
*(unsigned char *)equed = 'C';
}
} else if (colcnd >= THRESH) {
/* Row scaling, no column scaling */
for (j = 0; j < A->ncol; ++j)
for (i = Astore->colptr[j]; i < Astore->colptr[j+1]; ++i) {
irow = Astore->rowind[i];
cs_mult(&Aval[i], &Aval[i], r[irow]);
}
*(unsigned char *)equed = 'R';
} else {
/* Row and column scaling */
for (j = 0; j < A->ncol; ++j) {
cj = c[j];
for (i = Astore->colptr[j]; i < Astore->colptr[j+1]; ++i) {
irow = Astore->rowind[i];
temp = cj * r[irow];
cs_mult(&Aval[i], &Aval[i], temp);
}
}
*(unsigned char *)equed = 'B';
}
return;
} /* claqgs */
/*! \brief
*
* <pre>
* Purpose
* =======
*
* SGSEQU 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_S; Mtype = SLU_GE.
*
* R (output) float*, size A->nrow
* If INFO = 0 or INFO > M, R contains the row scale factors
* for A.
*
* C (output) float*, size A->ncol
* If INFO = 0, C contains the column scale factors for A.
*
* ROWCND (output) float*
* 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) float*
* 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) float*
* 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
* <= A->nrow: the i-th row of A is exactly zero
* > A->ncol: the (i-M)-th column of A is exactly zero
*
* =====================================================================
* </pre>
*/
void
sgsequ(SuperMatrix *A, float *r, float *c, float *rowcnd,
float *colcnd, float *amax, int *info)
{
/* Local variables */
NCformat *Astore;
float *Aval;
int i, j, irow;
float rcmin, rcmax;
float bignum, smlnum;
extern float smach(char *);
/* Test the input parameters. */
*info = 0;
if ( A->nrow < 0 || A->ncol < 0 ||
A->Stype != SLU_NC || A->Dtype != SLU_S || A->Mtype != SLU_GE )
*info = -1;
if (*info != 0) {
i = -(*info);
input_error("sgsequ", &i);
return;
}
/* Quick return if possible */
if ( A->nrow == 0 || A->ncol == 0 ) {
*rowcnd = 1.;
*colcnd = 1.;
*amax = 0.;
return;
}
Astore = A->Store;
Aval = Astore->nzval;
/* Get machine constants. */
smlnum = smach("S"); /* slamch_("S"); */
bignum = 1. / smlnum;
/* Compute row scale factors. */
for (i = 0; i < A->nrow; ++i) r[i] = 0.;
/* Find the maximum element in each row. */
for (j = 0; j < A->ncol; ++j)
for (i = Astore->colptr[j]; i < Astore->colptr[j+1]; ++i) {
irow = Astore->rowind[i];
r[irow] = SUPERLU_MAX( r[irow], fabs(Aval[i]) );
}
/* Find the maximum and minimum scale factors. */
rcmin = bignum;
rcmax = 0.;
for (i = 0; i < A->nrow; ++i) {
rcmax = SUPERLU_MAX(rcmax, r[i]);
rcmin = SUPERLU_MIN(rcmin, r[i]);
}
*amax = rcmax;
if (rcmin == 0.) {
/* Find the first zero scale factor and return an error code. */
for (i = 0; i < A->nrow; ++i)
if (r[i] == 0.) {
*info = i + 1;
return;
}
} else {
/* Invert the scale factors. */
for (i = 0; i < A->nrow; ++i)
r[i] = 1. / SUPERLU_MIN( SUPERLU_MAX( r[i], smlnum ), bignum );
/* Compute ROWCND = min(R(I)) / max(R(I)) */
*rowcnd = SUPERLU_MAX( rcmin, smlnum ) / SUPERLU_MIN( rcmax, bignum );
}
/* Compute column scale factors */
for (j = 0; j < A->ncol; ++j) c[j] = 0.;
/* Find the maximum element in each column, assuming the row
scalings computed above. */
for (j = 0; j < A->ncol; ++j)
for (i = Astore->colptr[j]; i < Astore->colptr[j+1]; ++i) {
irow = Astore->rowind[i];
c[j] = SUPERLU_MAX( c[j], fabs(Aval[i]) * r[irow] );
}
/* Find the maximum and minimum scale factors. */
rcmin = bignum;
rcmax = 0.;
for (j = 0; j < A->ncol; ++j) {
rcmax = SUPERLU_MAX(rcmax, c[j]);
rcmin = SUPERLU_MIN(rcmin, c[j]);
}
if (rcmin == 0.) {
/* Find the first zero scale factor and return an error code. */
for (j = 0; j < A->ncol; ++j)
if ( c[j] == 0. ) {
*info = A->nrow + j + 1;
return;
}
} else {
/* Invert the scale factors. */
for (j = 0; j < A->ncol; ++j)
c[j] = 1. / SUPERLU_MIN( SUPERLU_MAX( c[j], smlnum ), bignum);
/* Compute COLCND = min(C(J)) / max(C(J)) */
*colcnd = SUPERLU_MAX( rcmin, smlnum ) / SUPERLU_MIN( rcmax, bignum );
}
return;
} /* sgsequ */
float
cPivotGrowth(int ncols, SuperMatrix *A, int *perm_c,
SuperMatrix *L, SuperMatrix *U)
{
NCformat *Astore;
SCformat *Lstore;
NCformat *Ustore;
complex *Aval, *Lval, *Uval;
int fsupc, nsupr, luptr, nz_in_U;
int i, j, k, oldcol;
int *inv_perm_c;
float rpg, maxaj, maxuj;
float smlnum;
complex *luval;
complex temp_comp;
/* Get machine constants. */
smlnum = smach("S");
rpg = 1. / smlnum;
Astore = A->Store;
Lstore = L->Store;
Ustore = U->Store;
Aval = Astore->nzval;
Lval = Lstore->nzval;
Uval = Ustore->nzval;
inv_perm_c = (int *) SUPERLU_MALLOC(A->ncol*sizeof(int));
for (j = 0; j < A->ncol; ++j) inv_perm_c[perm_c[j]] = j;
for (k = 0; k <= Lstore->nsuper; ++k) {
fsupc = L_FST_SUPC(k);
nsupr = L_SUB_START(fsupc+1) - L_SUB_START(fsupc);
luptr = L_NZ_START(fsupc);
luval = &Lval[luptr];
nz_in_U = 1;
for (j = fsupc; j < L_FST_SUPC(k+1) && j < ncols; ++j) {
maxaj = 0.;
oldcol = inv_perm_c[j];
for (i = Astore->colptr[oldcol]; i < Astore->colptr[oldcol+1]; ++i)
maxaj = SUPERLU_MAX( maxaj, c_abs1( &Aval[i]) );
maxuj = 0.;
for (i = Ustore->colptr[j]; i < Ustore->colptr[j+1]; i++)
maxuj = SUPERLU_MAX( maxuj, c_abs1( &Uval[i]) );
/* Supernode */
for (i = 0; i < nz_in_U; ++i)
maxuj = SUPERLU_MAX( maxuj, c_abs1( &luval[i]) );
++nz_in_U;
luval += nsupr;
if ( maxuj == 0. )
rpg = SUPERLU_MIN( rpg, 1.);
else
rpg = SUPERLU_MIN( rpg, maxaj / maxuj );
}
if ( j >= ncols ) break;
}
SUPERLU_FREE(inv_perm_c);
return (rpg);
}
/* Subroutine */ int slatb4_slu(char *path, integer *imat, integer *m, integer *
n, char *type, integer *kl, integer *ku, real *anorm, integer *mode,
real *cndnum, char *dist)
{
/* Initialized data */
static logical first = TRUE_;
/* System generated locals */
integer i__1;
/* Builtin functions */
double sqrt(doublereal);
/* Local variables */
static real badc1, badc2, large, small;
static char c2[2];
extern /* Subroutine */ int slabad_slu(real *, real *);
extern float smach(char *);
static integer mat;
static real eps;
/* -- LAPACK test routine (version 2.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
February 29, 1992
Purpose
=======
SLATB4 sets parameters for the matrix generator based on the type of
matrix to be generated.
Arguments
=========
PATH (input) CHARACTER*3
The LAPACK path name.
IMAT (input) INTEGER
An integer key describing which matrix to generate for this
path.
M (input) INTEGER
The number of rows in the matrix to be generated.
N (input) INTEGER
The number of columns in the matrix to be generated.
TYPE (output) CHARACTER*1
The type of the matrix to be generated:
= 'S': symmetric matrix
= 'P': symmetric positive (semi)definite matrix
= 'N': nonsymmetric matrix
KL (output) INTEGER
The lower band width of the matrix to be generated.
KU (output) INTEGER
The upper band width of the matrix to be generated.
ANORM (output) REAL
The desired norm of the matrix to be generated. The diagonal
matrix of singular values or eigenvalues is scaled by this
value.
MODE (output) INTEGER
A key indicating how to choose the vector of eigenvalues.
CNDNUM (output) REAL
The desired condition number.
DIST (output) CHARACTER*1
The type of distribution to be used by the random number
generator.
=====================================================================
Set some constants for use in the subroutine. */
if (first) {
first = FALSE_;
eps = smach("Precision");
badc2 = .1f / eps;
badc1 = sqrt(badc2);
small = smach("Safe minimum");
large = 1.f / small;
/* If it looks like we're on a Cray, take the square root of
SMALL and LARGE to avoid overflow and underflow problems. */
slabad_slu(&small, &large);
small = small / eps * .25f;
large = 1.f / small;
}
strncpy(c2, path + 1, 2);
/* Set some parameters we don't plan to change. */
*(unsigned char *)dist = 'S';
*mode = 3;
if (strncmp(c2, "QR", 2)==0 || strncmp(c2, "LQ", 2)==0 ||
strncmp(c2, "QL", 2)==0 || strncmp(c2, "RQ", 2)==0 ) {
/* xQR, xLQ, xQL, xRQ: Set parameters to generate a general
M x N matrix.
Set TYPE, the type of matrix to be generated. */
*(unsigned char *)type = 'N';
/* Set the lower and upper bandwidths. */
if (*imat == 1) {
*kl = 0;
*ku = 0;
} else if (*imat == 2) {
*kl = 0;
/* Computing MAX */
i__1 = *n - 1;
*ku = max(i__1,0);
} else if (*imat == 3) {
/* Computing MAX */
i__1 = *m - 1;
*kl = max(i__1,0);
*ku = 0;
} else {
/* Computing MAX */
i__1 = *m - 1;
*kl = max(i__1,0);
/* Computing MAX */
i__1 = *n - 1;
*ku = max(i__1,0);
}
/* Set the condition number and norm. */
if (*imat == 5) {
*cndnum = badc1;
} else if (*imat == 6) {
*cndnum = badc2;
} else {
*cndnum = 2.f;
}
if (*imat == 7) {
*anorm = small;
} else if (*imat == 8) {
*anorm = large;
} else {
*anorm = 1.f;
}
} else if (strncmp(c2, "GE", 2)==0) {
/* xGE: Set parameters to generate a general M x N matrix.
Set TYPE, the type of matrix to be generated. */
*(unsigned char *)type = 'N';
/* Set the lower and upper bandwidths. */
if (*imat == 1) {
*kl = 0;
*ku = 0;
} else if (*imat == 2) {
*kl = 0;
/* Computing MAX */
i__1 = *n - 1;
*ku = max(i__1,0);
} else if (*imat == 3) {
/* Computing MAX */
i__1 = *m - 1;
*kl = max(i__1,0);
*ku = 0;
} else {
/* Computing MAX */
i__1 = *m - 1;
*kl = max(i__1,0);
/* Computing MAX */
i__1 = *n - 1;
*ku = max(i__1,0);
}
/* Set the condition number and norm. */
if (*imat == 8) {
*cndnum = badc1;
} else if (*imat == 9) {
*cndnum = badc2;
} else {
*cndnum = 2.f;
}
if (*imat == 10) {
*anorm = small;
} else if (*imat == 11) {
*anorm = large;
} else {
*anorm = 1.f;
}
} else if (strncmp(c2, "GB", 2)==0) {
/* xGB: Set parameters to generate a general banded matrix.
Set TYPE, the type of matrix to be generated. */
*(unsigned char *)type = 'N';
/* Set the condition number and norm. */
if (*imat == 5) {
*cndnum = badc1;
} else if (*imat == 6) {
*cndnum = badc2 * .1f;
} else {
*cndnum = 2.f;
}
if (*imat == 7) {
*anorm = small;
} else if (*imat == 8) {
*anorm = large;
} else {
*anorm = 1.f;
}
} else if (strncmp(c2, "GT", 2)==0) {
/* xGT: Set parameters to generate a general tridiagonal matri
x.
Set TYPE, the type of matrix to be generated. */
*(unsigned char *)type = 'N';
/* Set the lower and upper bandwidths. */
if (*imat == 1) {
*kl = 0;
} else {
*kl = 1;
}
*ku = *kl;
/* Set the condition number and norm. */
if (*imat == 3) {
*cndnum = badc1;
} else if (*imat == 4) {
*cndnum = badc2;
} else {
*cndnum = 2.f;
}
if (*imat == 5 || *imat == 11) {
*anorm = small;
} else if (*imat == 6 || *imat == 12) {
*anorm = large;
} else {
*anorm = 1.f;
}
} else if (strncmp(c2, "PO", 2)==0 || strncmp(c2, "PP", 2)==0 || strncmp(c2, "SY", 2)==0 ||
strncmp(c2, "SP", 2)==0) {
/* xPO, xPP, xSY, xSP: Set parameters to generate a
symmetric matrix.
Set TYPE, the type of matrix to be generated. */
*(unsigned char *)type = *(unsigned char *)c2;
/* Set the lower and upper bandwidths. */
if (*imat == 1) {
*kl = 0;
} else {
/* Computing MAX */
i__1 = *n - 1;
*kl = max(i__1,0);
}
*ku = *kl;
/* Set the condition number and norm. */
if (*imat == 6) {
*cndnum = badc1;
} else if (*imat == 7) {
*cndnum = badc2;
} else {
*cndnum = 2.f;
}
if (*imat == 8) {
*anorm = small;
} else if (*imat == 9) {
*anorm = large;
} else {
*anorm = 1.f;
}
} else if (strncmp(c2, "PB", 2)==0) {
/* xPB: Set parameters to generate a symmetric band matrix.
Set TYPE, the type of matrix to be generated. */
*(unsigned char *)type = 'P';
/* Set the norm and condition number. */
if (*imat == 5) {
*cndnum = badc1;
} else if (*imat == 6) {
*cndnum = badc2;
} else {
*cndnum = 2.f;
}
if (*imat == 7) {
*anorm = small;
} else if (*imat == 8) {
*anorm = large;
} else {
*anorm = 1.f;
}
} else if (strncmp(c2, "PT", 2)==0) {
/* xPT: Set parameters to generate a symmetric positive defini
te
tridiagonal matrix. */
*(unsigned char *)type = 'P';
if (*imat == 1) {
*kl = 0;
} else {
*kl = 1;
}
*ku = *kl;
/* Set the condition number and norm. */
if (*imat == 3) {
*cndnum = badc1;
} else if (*imat == 4) {
*cndnum = badc2;
} else {
*cndnum = 2.f;
}
if (*imat == 5 || *imat == 11) {
*anorm = small;
} else if (*imat == 6 || *imat == 12) {
*anorm = large;
} else {
*anorm = 1.f;
}
} else if (strncmp(c2, "TR", 2)==0 || strncmp(c2, "TP", 2)==0) {
/* xTR, xTP: Set parameters to generate a triangular matrix
Set TYPE, the type of matrix to be generated. */
*(unsigned char *)type = 'N';
/* Set the lower and upper bandwidths. */
mat = abs(*imat);
if (mat == 1 || mat == 7) {
*kl = 0;
*ku = 0;
} else if (*imat < 0) {
/* Computing MAX */
i__1 = *n - 1;
*kl = max(i__1,0);
*ku = 0;
} else {
*kl = 0;
/* Computing MAX */
i__1 = *n - 1;
*ku = max(i__1,0);
}
/* Set the condition number and norm. */
if (mat == 3 || mat == 9) {
*cndnum = badc1;
} else if (mat == 4) {
*cndnum = badc2;
} else if (mat == 10) {
*cndnum = badc2;
} else {
*cndnum = 2.f;
}
if (mat == 5) {
*anorm = small;
} else if (mat == 6) {
*anorm = large;
} else {
*anorm = 1.f;
}
} else if (strncmp(c2, "TB", 2)==0) {
/* xTB: Set parameters to generate a triangular band matrix.
Set TYPE, the type of matrix to be generated. */
*(unsigned char *)type = 'N';
/* Set the norm and condition number. */
if (*imat == 2 || *imat == 8) {
*cndnum = badc1;
} else if (*imat == 3 || *imat == 9) {
*cndnum = badc2;
} else {
*cndnum = 2.f;
}
if (*imat == 4) {
*anorm = small;
} else if (*imat == 5) {
*anorm = large;
} else {
*anorm = 1.f;
}
}
if (*n <= 1) {
*cndnum = 1.f;
}
return 0;
/* End of SLATB4 */
} /* slatb4_slu */
