GLOBAL void UMF_kernel_wrapup
(
NumericType *Numeric,
SymbolicType *Symbolic,
WorkType *Work
)
{
/* ---------------------------------------------------------------------- */
/* local variables */
/* ---------------------------------------------------------------------- */
Entry pivot_value ;
double d ;
Entry *D ;
Int i, k, col, row, llen, ulen, *ip, *Rperm, *Cperm, *Lilen, npiv, lp,
*Uilen, *Lip, *Uip, *Cperm_init, up, pivrow, pivcol, *Lpos, *Upos, *Wr,
*Wc, *Wp, *Frpos, *Fcpos, *Row_degree, *Col_degree, *Rperm_init,
n_row, n_col, n_inner, zero_pivot, nan_pivot, n1 ;
#ifndef NDEBUG
UMF_dump_matrix (Numeric, Work, FALSE) ;
#endif
DEBUG0 (("Kernel complete, Starting Kernel wrapup\n")) ;
n_row = Symbolic->n_row ;
n_col = Symbolic->n_col ;
n_inner = MIN (n_row, n_col) ;
Rperm = Numeric->Rperm ;
Cperm = Numeric->Cperm ;
Lilen = Numeric->Lilen ;
Uilen = Numeric->Uilen ;
Upos = Numeric->Upos ;
Lpos = Numeric->Lpos ;
Lip = Numeric->Lip ;
Uip = Numeric->Uip ;
D = Numeric->D ;
npiv = Work->npiv ;
Numeric->npiv = npiv ;
Numeric->ulen = Work->ulen ;
ASSERT (n_row == Numeric->n_row) ;
ASSERT (n_col == Symbolic->n_col) ;
DEBUG0 (("Wrap-up: npiv "ID" ulen "ID"\n", npiv, Numeric->ulen)) ;
ASSERT (npiv <= n_inner) ;
/* this will be nonzero only if matrix is singular or rectangular */
ASSERT (IMPLIES (npiv == n_col, Work->ulen == 0)) ;
/* ---------------------------------------------------------------------- */
/* find the smallest and largest entries in D */
/* ---------------------------------------------------------------------- */
for (k = 0 ; k < npiv ; k++)
{
pivot_value = D [k] ;
ABS (d, pivot_value) ;
zero_pivot = SCALAR_IS_ZERO (d) ;
nan_pivot = SCALAR_IS_NAN (d) ;
if (!zero_pivot)
{
/* the pivot is nonzero, but might be Inf or NaN */
Numeric->nnzpiv++ ;
}
if (k == 0)
{
Numeric->min_udiag = d ;
Numeric->max_udiag = d ;
}
else
{
/* min (abs (diag (U))) behaves as follows: If any entry is zero,
then the result is zero (regardless of the presence of NaN's).
Otherwise, if any entry is NaN, then the result is NaN.
Otherwise, the result is the smallest absolute value on the
diagonal of U.
*/
if (SCALAR_IS_NONZERO (Numeric->min_udiag))
{
if (zero_pivot || nan_pivot)
{
Numeric->min_udiag = d ;
}
else if (!SCALAR_IS_NAN (Numeric->min_udiag))
{
/* d and min_udiag are both non-NaN */
Numeric->min_udiag = MIN (Numeric->min_udiag, d) ;
}
}
/*
max (abs (diag (U))) behaves as follows: If any entry is NaN
then the result is NaN. Otherise, the result is the largest
absolute value on the diagonal of U.
*/
if (nan_pivot)
{
Numeric->max_udiag = d ;
}
else if (!SCALAR_IS_NAN (Numeric->max_udiag))
{
/* d and max_udiag are both non-NaN */
Numeric->max_udiag = MAX (Numeric->max_udiag, d) ;
}
}
}
/* ---------------------------------------------------------------------- */
/* check if matrix is singular or rectangular */
/* ---------------------------------------------------------------------- */
Col_degree = Cperm ; /* for NON_PIVOTAL_COL macro */
Row_degree = Rperm ; /* for NON_PIVOTAL_ROW macro */
if (npiv < n_row)
{
/* finalize the row permutation */
k = npiv ;
DEBUGm3 (("Singular pivot rows "ID" to "ID"\n", k, n_row-1)) ;
for (row = 0 ; row < n_row ; row++)
{
if (NON_PIVOTAL_ROW (row))
{
Rperm [row] = ONES_COMPLEMENT (k) ;
DEBUGm3 (("Singular row "ID" is k: "ID" pivot row\n", row, k)) ;
ASSERT (!NON_PIVOTAL_ROW (row)) ;
Lpos [row] = EMPTY ;
Uip [row] = EMPTY ;
Uilen [row] = 0 ;
k++ ;
}
}
ASSERT (k == n_row) ;
}
if (npiv < n_col)
{
/* finalize the col permutation */
k = npiv ;
DEBUGm3 (("Singular pivot cols "ID" to "ID"\n", k, n_col-1)) ;
for (col = 0 ; col < n_col ; col++)
{
if (NON_PIVOTAL_COL (col))
{
Cperm [col] = ONES_COMPLEMENT (k) ;
DEBUGm3 (("Singular col "ID" is k: "ID" pivot row\n", col, k)) ;
ASSERT (!NON_PIVOTAL_COL (col)) ;
Upos [col] = EMPTY ;
Lip [col] = EMPTY ;
Lilen [col] = 0 ;
k++ ;
}
}
ASSERT (k == n_col) ;
}
if (npiv < n_inner)
{
/* finalize the diagonal of U */
DEBUGm3 (("Diag of U is zero, "ID" to "ID"\n", npiv, n_inner-1)) ;
for (k = npiv ; k < n_inner ; k++)
{
CLEAR (D [k]) ;
}
}
/* save the pattern of the last row of U */
if (Numeric->ulen > 0)
{
DEBUGm3 (("Last row of U is not empty\n")) ;
Numeric->Upattern = Work->Upattern ;
Work->Upattern = (Int *) NULL ;
}
DEBUG2 (("Nnzpiv: "ID" npiv "ID"\n", Numeric->nnzpiv, npiv)) ;
ASSERT (Numeric->nnzpiv <= npiv) ;
if (Numeric->nnzpiv < n_inner && !SCALAR_IS_NAN (Numeric->min_udiag))
{
/* the rest of the diagonal is zero, so min_udiag becomes 0,
* unless it is already NaN. */
Numeric->min_udiag = 0.0 ;
}
/* ---------------------------------------------------------------------- */
/* size n_row, n_col workspaces that can be used here: */
/* ---------------------------------------------------------------------- */
Frpos = Work->Frpos ; /* of size n_row+1 */
Fcpos = Work->Fcpos ; /* of size n_col+1 */
Wp = Work->Wp ; /* of size MAX(n_row,n_col)+1 */
/* Work->Upattern ; cannot be used (in Numeric) */
Wr = Work->Lpattern ; /* of size n_row+1 */
Wc = Work->Wrp ; /* of size n_col+1 or bigger */
/* ---------------------------------------------------------------------- */
/* construct Rperm from inverse permutations */
/* ---------------------------------------------------------------------- */
/* use Frpos for temporary copy of inverse row permutation [ */
for (pivrow = 0 ; pivrow < n_row ; pivrow++)
{
k = Rperm [pivrow] ;
ASSERT (k < 0) ;
k = ONES_COMPLEMENT (k) ;
ASSERT (k >= 0 && k < n_row) ;
Wp [k] = pivrow ;
Frpos [pivrow] = k ;
}
for (k = 0 ; k < n_row ; k++)
{
Rperm [k] = Wp [k] ;
}
/* ---------------------------------------------------------------------- */
/* construct Cperm from inverse permutation */
/* ---------------------------------------------------------------------- */
/* use Fcpos for temporary copy of inverse column permutation [ */
for (pivcol = 0 ; pivcol < n_col ; pivcol++)
{
k = Cperm [pivcol] ;
ASSERT (k < 0) ;
k = ONES_COMPLEMENT (k) ;
ASSERT (k >= 0 && k < n_col) ;
Wp [k] = pivcol ;
/* save a copy of the inverse column permutation in Fcpos */
Fcpos [pivcol] = k ;
}
for (k = 0 ; k < n_col ; k++)
{
Cperm [k] = Wp [k] ;
}
#ifndef NDEBUG
for (k = 0 ; k < n_col ; k++)
{
col = Cperm [k] ;
ASSERT (col >= 0 && col < n_col) ;
ASSERT (Fcpos [col] == k) ; /* col is the kth pivot */
}
for (k = 0 ; k < n_row ; k++)
{
row = Rperm [k] ;
ASSERT (row >= 0 && row < n_row) ;
ASSERT (Frpos [row] == k) ; /* row is the kth pivot */
}
#endif
#ifndef NDEBUG
UMF_dump_lu (Numeric) ;
#endif
/* ---------------------------------------------------------------------- */
/* permute Lpos, Upos, Lilen, Lip, Uilen, and Uip */
/* ---------------------------------------------------------------------- */
for (k = 0 ; k < npiv ; k++)
{
pivrow = Rperm [k] ;
Wr [k] = Uilen [pivrow] ;
Wp [k] = Uip [pivrow] ;
}
for (k = 0 ; k < npiv ; k++)
{
Uilen [k] = Wr [k] ;
Uip [k] = Wp [k] ;
}
for (k = 0 ; k < npiv ; k++)
{
pivrow = Rperm [k] ;
Wp [k] = Lpos [pivrow] ;
}
for (k = 0 ; k < npiv ; k++)
{
Lpos [k] = Wp [k] ;
}
for (k = 0 ; k < npiv ; k++)
{
pivcol = Cperm [k] ;
Wc [k] = Lilen [pivcol] ;
Wp [k] = Lip [pivcol] ;
}
for (k = 0 ; k < npiv ; k++)
{
Lilen [k] = Wc [k] ;
Lip [k] = Wp [k] ;
}
for (k = 0 ; k < npiv ; k++)
{
pivcol = Cperm [k] ;
Wp [k] = Upos [pivcol] ;
}
for (k = 0 ; k < npiv ; k++)
{
Upos [k] = Wp [k] ;
}
/* ---------------------------------------------------------------------- */
/* terminate the last Uchain and last Lchain */
/* ---------------------------------------------------------------------- */
Upos [npiv] = EMPTY ;
Lpos [npiv] = EMPTY ;
Uip [npiv] = EMPTY ;
Lip [npiv] = EMPTY ;
Uilen [npiv] = 0 ;
Lilen [npiv] = 0 ;
/* ---------------------------------------------------------------------- */
/* convert U to the new pivot order */
/* ---------------------------------------------------------------------- */
n1 = Symbolic->n1 ;
for (k = 0 ; k < n1 ; k++)
{
/* this is a singleton row of U */
ulen = Uilen [k] ;
DEBUG4 (("K "ID" New U. ulen "ID" Singleton 1\n", k, ulen)) ;
if (ulen > 0)
{
up = Uip [k] ;
ip = (Int *) (Numeric->Memory + up) ;
for (i = 0 ; i < ulen ; i++)
{
col = *ip ;
DEBUG4 ((" old col "ID" new col "ID"\n", col, Fcpos [col]));
ASSERT (col >= 0 && col < n_col) ;
*ip++ = Fcpos [col] ;
}
}
}
for (k = n1 ; k < npiv ; k++)
{
up = Uip [k] ;
if (up < 0)
{
/* this is the start of a new Uchain (with a pattern) */
ulen = Uilen [k] ;
DEBUG4 (("K "ID" New U. ulen "ID" End_Uchain 1\n", k, ulen)) ;
if (ulen > 0)
{
up = -up ;
ip = (Int *) (Numeric->Memory + up) ;
for (i = 0 ; i < ulen ; i++)
{
col = *ip ;
DEBUG4 ((" old col "ID" new col "ID"\n", col, Fcpos [col]));
ASSERT (col >= 0 && col < n_col) ;
*ip++ = Fcpos [col] ;
}
}
}
}
ulen = Numeric->ulen ;
if (ulen > 0)
{
/* convert last pivot row of U to the new pivot order */
DEBUG4 (("K "ID" (last)\n", k)) ;
for (i = 0 ; i < ulen ; i++)
{
col = Numeric->Upattern [i] ;
DEBUG4 ((" old col "ID" new col "ID"\n", col, Fcpos [col])) ;
Numeric->Upattern [i] = Fcpos [col] ;
}
}
/* Fcpos no longer needed ] */
/* ---------------------------------------------------------------------- */
/* convert L to the new pivot order */
/* ---------------------------------------------------------------------- */
for (k = 0 ; k < n1 ; k++)
{
llen = Lilen [k] ;
DEBUG4 (("K "ID" New L. llen "ID" Singleton col\n", k, llen)) ;
if (llen > 0)
{
lp = Lip [k] ;
ip = (Int *) (Numeric->Memory + lp) ;
for (i = 0 ; i < llen ; i++)
{
row = *ip ;
DEBUG4 ((" old row "ID" new row "ID"\n", row, Frpos [row])) ;
ASSERT (row >= 0 && row < n_row) ;
*ip++ = Frpos [row] ;
}
}
}
for (k = n1 ; k < npiv ; k++)
{
llen = Lilen [k] ;
DEBUG4 (("K "ID" New L. llen "ID" \n", k, llen)) ;
if (llen > 0)
{
lp = Lip [k] ;
if (lp < 0)
{
/* this starts a new Lchain */
lp = -lp ;
}
ip = (Int *) (Numeric->Memory + lp) ;
for (i = 0 ; i < llen ; i++)
{
row = *ip ;
DEBUG4 ((" old row "ID" new row "ID"\n", row, Frpos [row])) ;
ASSERT (row >= 0 && row < n_row) ;
*ip++ = Frpos [row] ;
}
}
}
/* Frpos no longer needed ] */
/* ---------------------------------------------------------------------- */
/* combine symbolic and numeric permutations */
/* ---------------------------------------------------------------------- */
Cperm_init = Symbolic->Cperm_init ;
Rperm_init = Symbolic->Rperm_init ;
for (k = 0 ; k < n_row ; k++)
{
Rperm [k] = Rperm_init [Rperm [k]] ;
}
for (k = 0 ; k < n_col ; k++)
{
Cperm [k] = Cperm_init [Cperm [k]] ;
}
/* Work object will be freed immediately upon return (to UMF_kernel */
/* and then to UMFPACK_numeric). */
}
GLOBAL void UMF_scale_column
(
NumericType *Numeric,
WorkType *Work
)
{
/* ---------------------------------------------------------------------- */
/* local variables */
/* ---------------------------------------------------------------------- */
Entry pivot_value ;
Entry *Fcol, *Flublock, *Flblock, *Fublock, *Fcblock ;
Int k, k1, fnr_curr, fnrows, fncols, *Frpos, *Fcpos, pivrow, pivcol,
*Frows, *Fcols, fnc_curr, fnpiv, *Row_tuples, nb,
*Col_tuples, *Rperm, *Cperm, fspos, col2, row2 ;
#ifndef NDEBUG
Int *Col_degree, *Row_degree ;
#endif
/* ---------------------------------------------------------------------- */
/* get parameters */
/* ---------------------------------------------------------------------- */
fnrows = Work->fnrows ;
fncols = Work->fncols ;
fnpiv = Work->fnpiv ;
/* ---------------------------------------------------------------------- */
Rperm = Numeric->Rperm ;
Cperm = Numeric->Cperm ;
/* ---------------------------------------------------------------------- */
Flublock = Work->Flublock ;
Flblock = Work->Flblock ;
Fublock = Work->Fublock ;
Fcblock = Work->Fcblock ;
fnr_curr = Work->fnr_curr ;
fnc_curr = Work->fnc_curr ;
Frpos = Work->Frpos ;
Fcpos = Work->Fcpos ;
Frows = Work->Frows ;
Fcols = Work->Fcols ;
pivrow = Work->pivrow ;
pivcol = Work->pivcol ;
ASSERT (pivrow >= 0 && pivrow < Work->n_row) ;
ASSERT (pivcol >= 0 && pivcol < Work->n_col) ;
#ifndef NDEBUG
Col_degree = Numeric->Cperm ; /* for NON_PIVOTAL_COL macro */
Row_degree = Numeric->Rperm ; /* for NON_PIVOTAL_ROW macro */
#endif
Row_tuples = Numeric->Uip ;
Col_tuples = Numeric->Lip ;
nb = Work->nb ;
#ifndef NDEBUG
ASSERT (fnrows == Work->fnrows_new + 1) ;
ASSERT (fncols == Work->fncols_new + 1) ;
DEBUG1 (("SCALE COL: fnrows "ID" fncols "ID"\n", fnrows, fncols)) ;
DEBUG2 (("\nFrontal matrix, including all space:\n"
"fnr_curr "ID" fnc_curr "ID" nb "ID"\n"
"fnrows "ID" fncols "ID" fnpiv "ID"\n",
fnr_curr, fnc_curr, nb, fnrows, fncols, fnpiv)) ;
DEBUG2 (("\nJust the active part:\n")) ;
DEBUG7 (("C block: ")) ;
UMF_dump_dense (Fcblock, fnr_curr, fnrows, fncols) ;
DEBUG7 (("L block: ")) ;
UMF_dump_dense (Flblock, fnr_curr, fnrows, fnpiv);
DEBUG7 (("U' block: ")) ;
UMF_dump_dense (Fublock, fnc_curr, fncols, fnpiv) ;
DEBUG7 (("LU block: ")) ;
UMF_dump_dense (Flublock, nb, fnpiv, fnpiv) ;
#endif
/* ====================================================================== */
/* === Shift pivot row and column ======================================= */
/* ====================================================================== */
/* ---------------------------------------------------------------------- */
/* move pivot column into place */
/* ---------------------------------------------------------------------- */
/* Note that the pivot column is already in place. Just shift the last
* column into the position vacated by the pivot column. */
fspos = Fcpos [pivcol] ;
/* one less column in the contribution block */
fncols = --(Work->fncols) ;
if (fspos != fncols * fnr_curr)
{
Int fs = fspos / fnr_curr ;
DEBUG6 (("Shift pivot column in front\n")) ;
DEBUG6 (("fspos: "ID" flpos: "ID"\n", fspos, fncols * fnr_curr)) ;
/* ------------------------------------------------------------------ */
/* move Fe => Fs */
/* ------------------------------------------------------------------ */
/* column of the contribution block: */
{
/* Fs: current position of pivot column in contribution block */
/* Fe: position of last column in contribution block */
Int i ;
Entry *Fs, *Fe ;
Fs = Fcblock + fspos ;
Fe = Fcblock + fncols * fnr_curr ;
#pragma ivdep
for (i = 0 ; i < fnrows ; i++)
{
Fs [i] = Fe [i] ;
}
}
/* column of the U2 block */
{
/* Fs: current position of pivot column in U block */
/* Fe: last column in U block */
Int i ;
Entry *Fs, *Fe ;
Fs = Fublock + fs ;
Fe = Fublock + fncols ;
#pragma ivdep
for (i = 0 ; i < fnpiv ; i++)
{
Fs [i * fnc_curr] = Fe [i * fnc_curr] ;
}
}
/* move column Fe to Fs in the Fcols pattern */
col2 = Fcols [fncols] ;
Fcols [fs] = col2 ;
Fcpos [col2] = fspos ;
}
/* pivot column is no longer in the frontal matrix */
Fcpos [pivcol] = EMPTY ;
#ifndef NDEBUG
DEBUG2 (("\nFrontal matrix after col swap, including all space:\n"
"fnr_curr "ID" fnc_curr "ID" nb "ID"\n"
"fnrows "ID" fncols "ID" fnpiv "ID"\n",
fnr_curr, fnc_curr, nb,
fnrows, fncols, fnpiv)) ;
DEBUG2 (("\nJust the active part:\n")) ;
DEBUG7 (("C block: ")) ;
UMF_dump_dense (Fcblock, fnr_curr, fnrows, fncols) ;
DEBUG7 (("L block: ")) ;
UMF_dump_dense (Flblock, fnr_curr, fnrows, fnpiv+1);
DEBUG7 (("U' block: ")) ;
UMF_dump_dense (Fublock, fnc_curr, fncols, fnpiv) ;
DEBUG7 (("LU block: ")) ;
UMF_dump_dense (Flublock, nb, fnpiv, fnpiv+1) ;
#endif
/* ---------------------------------------------------------------------- */
/* move pivot row into place */
/* ---------------------------------------------------------------------- */
fspos = Frpos [pivrow] ;
/* one less row in the contribution block */
fnrows = --(Work->fnrows) ;
DEBUG6 (("Swap/shift pivot row in front:\n")) ;
DEBUG6 (("fspos: "ID" flpos: "ID"\n", fspos, fnrows)) ;
if (fspos == fnrows)
{
/* ------------------------------------------------------------------ */
/* move Fs => Fd */
/* ------------------------------------------------------------------ */
DEBUG6 (("row case 1\n")) ;
/* row of the contribution block: */
{
Int j ;
Entry *Fd, *Fs ;
Fd = Fublock + fnpiv * fnc_curr ;
Fs = Fcblock + fspos ;
#pragma ivdep
for (j = 0 ; j < fncols ; j++)
{
Fd [j] = Fs [j * fnr_curr] ;
}
}
/* row of the L2 block: */
if (Work->pivrow_in_front)
{
Int j ;
Entry *Fd, *Fs ;
Fd = Flublock + fnpiv ;
Fs = Flblock + fspos ;
#pragma ivdep
for (j = 0 ; j <= fnpiv ; j++)
{
Fd [j * nb] = Fs [j * fnr_curr] ;
}
}
else
{
Int j ;
Entry *Fd, *Fs ;
Fd = Flublock + fnpiv ;
Fs = Flblock + fspos ;
#pragma ivdep
for (j = 0 ; j < fnpiv ; j++)
{
ASSERT (IS_ZERO (Fs [j * fnr_curr])) ;
CLEAR (Fd [j * nb]) ;
}
Fd [fnpiv * nb] = Fs [fnpiv * fnr_curr] ;
}
}
else
{
/* ------------------------------------------------------------------ */
/* move Fs => Fd */
/* move Fe => Fs */
/* ------------------------------------------------------------------ */
DEBUG6 (("row case 2\n")) ;
/* this is the most common case, by far */
/* row of the contribution block: */
{
/* Fd: destination of pivot row on U block */
/* Fs: current position of pivot row in contribution block */
/* Fe: position of last row in contribution block */
Entry *Fd, *Fs, *Fe ;
Fd = Fublock + fnpiv * fnc_curr ;
Fs = Fcblock + fspos ;
Fe = Fcblock + fnrows ;
shift_pivot_row (Fd, Fs, Fe, fncols, fnr_curr) ;
}
/* row of the L2 block: */
if (Work->pivrow_in_front)
{
/* Fd: destination of pivot row in LU block */
/* Fs: current position of pivot row in L block */
/* Fe: last row in L block */
Int j ;
Entry *Fd, *Fs, *Fe ;
Fd = Flublock + fnpiv ;
Fs = Flblock + fspos ;
Fe = Flblock + fnrows ;
#pragma ivdep
for (j = 0 ; j <= fnpiv ; j++)
{
Fd [j * nb] = Fs [j * fnr_curr] ;
Fs [j * fnr_curr] = Fe [j * fnr_curr] ;
}
}
else
{
Int j ;
Entry *Fd, *Fs, *Fe ;
Fd = Flublock + fnpiv ;
Fs = Flblock + fspos ;
Fe = Flblock + fnrows ;
#pragma ivdep
for (j = 0 ; j < fnpiv ; j++)
{
ASSERT (IS_ZERO (Fs [j * fnr_curr])) ;
CLEAR (Fd [j * nb]) ;
Fs [j * fnr_curr] = Fe [j * fnr_curr] ;
}
Fd [fnpiv * nb] = Fs [fnpiv * fnr_curr] ;
Fs [fnpiv * fnr_curr] = Fe [fnpiv * fnr_curr] ;
}
/* move row Fe to Fs in the Frows pattern */
row2 = Frows [fnrows] ;
Frows [fspos] = row2 ;
Frpos [row2] = fspos ;
}
/* pivot row is no longer in the frontal matrix */
Frpos [pivrow] = EMPTY ;
#ifndef NDEBUG
DEBUG2 (("\nFrontal matrix after row swap, including all space:\n"
"fnr_curr "ID" fnc_curr "ID" nb "ID"\n"
"fnrows "ID" fncols "ID" fnpiv "ID"\n",
Work->fnr_curr, Work->fnc_curr, Work->nb,
Work->fnrows, Work->fncols, Work->fnpiv)) ;
DEBUG2 (("\nJust the active part:\n")) ;
DEBUG7 (("C block: ")) ;
UMF_dump_dense (Fcblock, fnr_curr, fnrows, fncols) ;
DEBUG7 (("L block: ")) ;
UMF_dump_dense (Flblock, fnr_curr, fnrows, fnpiv+1);
DEBUG7 (("U' block: ")) ;
UMF_dump_dense (Fublock, fnc_curr, fncols, fnpiv+1) ;
DEBUG7 (("LU block: ")) ;
UMF_dump_dense (Flublock, nb, fnpiv+1, fnpiv+1) ;
#endif
/* ---------------------------------------------------------------------- */
/* Frpos [row] >= 0 for each row in pivot column pattern. */
/* offset into pattern is given by: */
/* Frpos [row] == offset - 1 */
/* Frpos [pivrow] is EMPTY */
/* Fcpos [col] >= 0 for each col in pivot row pattern. */
/* Fcpos [col] == (offset - 1) * fnr_curr */
/* Fcpos [pivcol] is EMPTY */
/* Fcols [0..fncols-1] is the pivot row pattern (excl pivot cols) */
/* Frows [0..fnrows-1] is the pivot col pattern (excl pivot rows) */
/* ====================================================================== */
/* === scale pivot column =============================================== */
/* ====================================================================== */
/* pivot column (except for pivot entry itself) */
Fcol = Flblock + fnpiv * fnr_curr ;
/* fnpiv-th pivot in frontal matrix located in Flublock (fnpiv, fnpiv) */
pivot_value = Flublock [fnpiv + fnpiv * nb] ;
/* this is the kth global pivot */
k = Work->npiv + fnpiv ;
DEBUG4 (("Pivot value: ")) ;
EDEBUG4 (pivot_value) ;
DEBUG4 (("\n")) ;
UMF_scale (fnrows, pivot_value, Fcol) ;
/* ---------------------------------------------------------------------- */
/* deallocate the pivot row and pivot column tuples */
/* ---------------------------------------------------------------------- */
UMF_mem_free_tail_block (Numeric, Row_tuples [pivrow]) ;
UMF_mem_free_tail_block (Numeric, Col_tuples [pivcol]) ;
Row_tuples [pivrow] = 0 ;
Col_tuples [pivcol] = 0 ;
DEBUG5 (("number of pivots prior to this one: "ID"\n", k)) ;
ASSERT (NON_PIVOTAL_ROW (pivrow)) ;
ASSERT (NON_PIVOTAL_COL (pivcol)) ;
/* save row and column inverse permutation */
k1 = ONES_COMPLEMENT (k) ;
Rperm [pivrow] = k1 ; /* aliased with Row_degree */
Cperm [pivcol] = k1 ; /* aliased with Col_degree */
ASSERT (!NON_PIVOTAL_ROW (pivrow)) ;
ASSERT (!NON_PIVOTAL_COL (pivcol)) ;
/* ---------------------------------------------------------------------- */
/* Keep track of the pivot order. This is the kth pivot row and column. */
/* ---------------------------------------------------------------------- */
/* keep track of pivot rows and columns in the LU, L, and U blocks */
ASSERT (fnpiv < MAXNB) ;
Work->Pivrow [fnpiv] = pivrow ;
Work->Pivcol [fnpiv] = pivcol ;
/* ====================================================================== */
/* === one step in the factorization is done ============================ */
/* ====================================================================== */
/* One more step is done, except for pending updates to the U and C blocks
* of this frontal matrix. Those are saved up, and applied by
* UMF_blas3_update when enough pivots have accumulated. Also, the
* LU factors for these pending pivots have not yet been stored. */
Work->fnpiv++ ;
#ifndef NDEBUG
DEBUG7 (("Current frontal matrix: (after pivcol scale)\n")) ;
UMF_dump_current_front (Numeric, Work, TRUE) ;
#endif
}
