if (Next [newcol] == IS_WEAK)
{
/* add this column to the list of weak nodes */
- DEBUGm1 ((" newcol "ID" has a weak diagonal deg "ID"\n",
+ DEBUGm1 ((" newcol " ID " has a weak diagonal deg " ID "\n",
newcol, deg)) ;
deg = Degree [newcol] ;
ASSERT (deg >= 0 && deg < n2) ;
for (deg = mindeg ; deg <= maxdeg ; deg++)
{
/* find the next weak diagonal of lowest degree */
- DEBUGm2 (("---------------------------------- Deg: "ID"\n", deg)) ;
+ DEBUGm2 (("---------------------------------- Deg: " ID "\n", deg)) ;
for (k = Head [deg] ; k != EMPTY ; k = Next [k])
{
- DEBUGm2 (("k: "ID"\n", k)) ;
+ DEBUGm2 (("k: " ID "\n", k)) ;
if (P [k] == EMPTY)
{
/* C (k,k) is a weak diagonal entry. Find an index j != k such
*
* Note that row k of R and column k of C are both sorted. */
- DEBUGm4 (("===== Weak diagonal k = "ID"\n", k)) ;
+ DEBUGm4 (("===== Weak diagonal k = " ID "\n", k)) ;
DEBUG1 (("Column k of C:\n")) ;
for (p = Cp [k] ; p < Cp [k+1] ; p++)
{
- DEBUG1 ((" "ID": deg "ID"\n", Ci [p], Degree [Ci [p]]));
+ DEBUG1 ((" " ID ": deg " ID "\n", Ci [p], Degree [Ci [p]]));
}
DEBUG1 (("Row k of R (strong entries only):\n")) ;
for (p = Rp [k] ; p < Rp [k+1] ; p++)
{
- DEBUG1 ((" "ID": deg "ID"\n", Ri [p], Degree [Ri [p]]));
+ DEBUG1 ((" " ID ": deg " ID "\n", Ri [p], Degree [Ri [p]]));
}
/* no (C (k,j), C (j,k)) pair exists yet */
jdeg = Degree [j] ;
jdiff = SCALAR_ABS (k-j) ;
- DEBUG1 (("Try candidate j "ID" deg "ID" diff "ID
+ DEBUG1 (("Try candidate j " ID " deg " ID " diff " ID
"\n", j, jdeg, jdiff)) ;
if (j_best == EMPTY)
{
/* j is best match for k */
/* found a strong pair, A (j,k) and A (k,j) */
- DEBUG1 ((" --- Found pair k: "ID" j: " ID
- " jdeg: "ID" jdiff: "ID"\n",
+ DEBUG1 ((" --- Found pair k: " ID " j: " ID
+ " jdeg: " ID " jdiff: " ID "\n",
k, j, jdeg, jdiff)) ;
ASSERT (jdiff != EMPTY) ;
ASSERT (jdeg != EMPTY) ;
if (j_best != EMPTY)
{
j = j_best ;
- DEBUGm4 ((" --- best pair j: "ID" for k: "ID"\n", j, k)) ;
+ DEBUGm4 ((" --- best pair j: " ID " for k: " ID "\n", j, k)) ;
P [k] = j ;
P [j] = k ;
}
do_max = FALSE ;
}
do_scale = do_max || do_sum ;
- DEBUGm3 (("do_values "ID" do_sum "ID" do_max "ID" do_scale "ID"\n",
+ DEBUGm3 (("do_values " ID " do_sum " ID " do_max " ID " do_scale " ID "\n",
do_values, do_sum, do_max, do_scale)) ;
/* ---------------------------------------------------------------------- */
oldcol = Cperm1 [k] ;
newcol = k - n1 ;
Next [newcol] = EMPTY ;
- DEBUGm1 (("Column "ID" newcol "ID" oldcol "ID"\n", k, newcol, oldcol)) ;
+ DEBUGm1 (("Column " ID " newcol " ID " oldcol " ID "\n", k, newcol, oldcol)) ;
Cp [newcol] = pp ;
}
ctol = tol * cmax ;
- DEBUGm1 ((" cmax col "ID" %g ctol %g\n", oldcol, cmax, ctol)) ;
+ DEBUGm1 ((" cmax col " ID " %g ctol %g\n", oldcol, cmax, ctol)) ;
}
else
{
weak = WEAK (value, ctol) ;
if (!weak)
{
- DEBUG0 ((" strong: row "ID": %g\n", oldrow, value)) ;
+ DEBUG0 ((" strong: row " ID ": %g\n", oldrow, value)) ;
Ci [pp++] = newrow ;
Ri [newrow]++ ;
}
weak = WEAK (value, ctol) ;
if (!weak)
{
- DEBUG0 ((" strong: row "ID": %g\n", oldrow, value)) ;
+ DEBUG0 ((" strong: row " ID ": %g\n", oldrow, value)) ;
Ci [pp++] = newrow ;
Ri [newrow]++ ;
}
weak = WEAK (value, ctol) ;
if (!weak)
{
- DEBUG0 ((" strong: row "ID": %g\n", oldrow, value)) ;
+ DEBUG0 ((" strong: row " ID ": %g\n", oldrow, value)) ;
Ci [pp++] = newrow ;
Ri [newrow]++ ;
}
*p_unmatched = unmatched ;
#ifndef NDEBUG
- DEBUGm4 (("UMF_2by2: weak "ID" unmatched "ID"\n", nweak, unmatched)) ;
+ DEBUGm4 (("UMF_2by2: weak " ID " unmatched " ID "\n", nweak, unmatched)) ;
for (row = 0 ; row < n ; row++)
{
- DEBUGm2 (("P ["ID"] = "ID"\n", row, P [row])) ;
+ DEBUGm2 (("P [" ID "] = " ID "\n", row, P [row])) ;
}
DEBUGm2 (("\n =============================UMF_2by2: done\n\n")) ;
#endif
Wflag, npivcol, fallrows, fallcols, fpiv, frows, fcols, *Front_size ;
nfr = 0 ;
- DEBUG0 (("UMF_analyze: anzmax "ID" anrow "ID" ancol "ID"\n",
+ DEBUG0 (("UMF_analyze: anzmax " ID " anrow " ID " ancol " ID "\n",
Ap [n_row], n_row, n_col)) ;
/* ====================================================================== */
for (j = 0 ; j < n_col ; j = jnext)
{
- DEBUG1 (("\n\n============Front "ID" starting. nfr = "ID"\n", j, nfr)) ;
+ DEBUG1 (("\n\n============Front " ID " starting. nfr = " ID "\n", j, nfr)) ;
/* ================================================================== */
/* === garbage collection =========================================== */
/* we might run out ... compact the rows of U */
#ifndef NDEBUG
- DEBUG0 (("UMF_analyze COMPACTION, j="ID" pfirst="ID"\n",
+ DEBUG0 (("UMF_analyze COMPACTION, j=" ID " pfirst=" ID "\n",
j, pfirst)) ;
for (row = 0 ; row < j ; row++)
{
if (Up [row] != EMPTY)
{
/* this is a live row of U */
- DEBUG1 (("Live row: "ID" cols: ", row)) ;
+ DEBUG1 (("Live row: " ID " cols: ", row)) ;
p = Up [row] ;
ASSERT (Front_ncols [row] > Front_npivcol [row]) ;
p2 = p + (Front_ncols [row] - Front_npivcol [row]) ;
if (Up [row] != EMPTY)
{
/* this is a live row of U */
- DEBUG1 (("Live row: "ID" cols: ", row)) ;
+ DEBUG1 (("Live row: " ID " cols: ", row)) ;
ASSERT (row < n_col) ;
p = Up [row] ;
ASSERT (Front_ncols [row] > Front_npivcol [row]) ;
}
#ifndef NDEBUG
- DEBUG1 (("\nAFTER COMPACTION, j="ID" pfirst="ID"\n", j, pfirst)) ;
+ DEBUG1 (("\nAFTER COMPACTION, j=" ID " pfirst=" ID "\n", j, pfirst)) ;
for (row = 0 ; row < j ; row++)
{
if (Up [row] != EMPTY)
{
/* this is a live row of U */
- DEBUG1 (("Live row: "ID" cols: ", row)) ;
+ DEBUG1 (("Live row: " ID " cols: ", row)) ;
p = Up [row] ;
ASSERT (Front_ncols [row] > Front_npivcol [row]) ;
p2 = p + (Front_ncols [row] - Front_npivcol [row]) ;
if (jlast != EMPTY && Link [j] == jlast)
{
/* yes - create row j by appending to jlast */
- DEBUG1 (("GOT:last front is child of this one: j "ID" jlast "ID"\n",
+ DEBUG1 (("GOT:last front is child of this one: j " ID " jlast " ID "\n",
j, jlast)) ;
ASSERT (jlast >= 0 && jlast < j) ;
for (p = Up [j] ; p < pdest ; )
{
j3 = Ai [p] ;
- DEBUG1 (("Initial row of U: col "ID" ", j3)) ;
+ DEBUG1 (("Initial row of U: col " ID " ", j3)) ;
ASSERT (j3 >= 0 && j3 < n_col) ;
- DEBUG1 (("W: "ID" \n", W [j3])) ;
+ DEBUG1 (("W: " ID " \n", W [j3])) ;
ASSERT (W [j3] == Wflag) ;
if (j == j3)
{
- DEBUG1 (("Found column j at p = "ID"\n", p)) ;
+ DEBUG1 (("Found column j at p = " ID "\n", p)) ;
Ai [p] = Ai [--pdest] ;
}
else
ASSERT (Front_nrows [jlast] > Front_npivcol [jlast]) ;
thickness = (Front_nrows [jlast] - Front_npivcol [jlast]) ;
- DEBUG1 (("initial thickness: "ID"\n", thickness)) ;
+ DEBUG1 (("initial thickness: " ID "\n", thickness)) ;
}
else
ASSERT (pdest <= pfirst) ;
W [j] = Wflag ;
- DEBUG1 (("\nComputing row "ID" of A'*A\n", j)) ;
- DEBUG2 ((" col: "ID" (diagonal)\n", j)) ;
+ DEBUG1 (("\nComputing row " ID " of A'*A\n", j)) ;
+ DEBUG2 ((" col: " ID " (diagonal)\n", j)) ;
/* ------------------------------------------------------------------ */
/* find the rows the contribute to this column j */
ASSERT (p < p2) ;
/* merge row k of A into W */
- DEBUG2 ((" ---- A row "ID" ", k)) ;
+ DEBUG2 ((" ---- A row " ID " ", k)) ;
ASSERT (k >= 0 && k < n_row) ;
ASSERT (Ai [p] == j) ;
- DEBUG2 ((" p "ID" p2 "ID"\n cols:", p, p2)) ;
+ DEBUG2 ((" p " ID " p2 " ID "\n cols:", p, p2)) ;
ASSERT (p >= pfirst && p < Ap [n_row]) ;
ASSERT (p2 > pfirst && p2 <= Ap [n_row]) ;
for ( ; p < p2 ; p++)
/* add to pattern if seen for the first time */
col = Ai [p] ;
ASSERT (col >= j && col < n_col) ;
- DEBUG3 ((" "ID, col)) ;
+ DEBUG3 ((" " ID, col)) ;
if (W [col] != Wflag)
{
Ai [pdest++] = col ;
}
#ifndef NDEBUG
- DEBUG3 (("\nRow "ID" of A'A:\n", j)) ;
+ DEBUG3 (("\nRow " ID " of A'A:\n", j)) ;
for (p = Up [j] ; p < pdest ; p++)
{
- DEBUG3 ((" "ID, Ai [p])) ;
+ DEBUG3 ((" " ID, Ai [p])) ;
}
DEBUG3 (("\n")) ;
#endif
for (k = Link [j] ; k != EMPTY ; k = Link [k])
{
/* merge row k of U into W */
- DEBUG2 ((" ---- U row "ID, k)) ;
+ DEBUG2 ((" ---- U row " ID, k)) ;
ASSERT (k >= 0 && k < n_col) ;
ASSERT (Up [k] != EMPTY) ;
p = Up [k] ;
ASSERT (Front_ncols [k] > Front_npivcol [k]) ;
p2 = p + (Front_ncols [k] - Front_npivcol [k]) ;
- DEBUG2 ((" p "ID" p2 "ID"\n cols:", p, p2)) ;
+ DEBUG2 ((" p " ID " p2 " ID "\n cols:", p, p2)) ;
ASSERT (p <= pfirst) ;
ASSERT (p2 <= pfirst) ;
for ( ; p < p2 ; p++)
/* add to pattern if seen for the first time */
col = Ai [p] ;
ASSERT (col >= j && col < n_col) ;
- DEBUG3 ((" "ID, col)) ;
+ DEBUG3 ((" " ID, col)) ;
if (W [col] != Wflag)
{
Ai [pdest++] = col ;
}
#ifndef NDEBUG
- DEBUG3 (("\nRow "ID" of U prior to supercolumn detection:\n", j));
+ DEBUG3 (("\nRow " ID " of U prior to supercolumn detection:\n", j));
for (p = Up [j] ; p < pdest ; p++)
{
- DEBUG3 ((" "ID, Ai [p])) ;
+ DEBUG3 ((" " ID, Ai [p])) ;
}
DEBUG3 (("\n")) ;
- DEBUG1 (("thickness, prior to supercol detect: "ID"\n", thickness)) ;
+ DEBUG1 (("thickness, prior to supercol detect: " ID "\n", thickness)) ;
#endif
/* ================================================================== */
}
/* the loop above terminated with j2 at the first non-supernode */
- DEBUG1 (("jnext = "ID"\n", jnext)) ;
+ DEBUG1 (("jnext = " ID "\n", jnext)) ;
ASSERT (j2 <= jnext) ;
jnext = j2 ;
j2-- ;
- DEBUG1 (("j2 = "ID"\n", j2)) ;
+ DEBUG1 (("j2 = " ID "\n", j2)) ;
ASSERT (j2 < n_col) ;
npivots = j2-j+1 ;
- DEBUG1 (("Number of pivot columns: "ID"\n", npivots)) ;
+ DEBUG1 (("Number of pivot columns: " ID "\n", npivots)) ;
/* rows j:j2 have the same nonzero pattern, except for columns j:j2-1 */
/* supernode detected, prune the pattern of new row j */
ASSERT (parent == j+1) ;
ASSERT (j2 < n_col) ;
- DEBUG1 (("Supernode detected, j "ID" to j2 "ID"\n", j, j2)) ;
+ DEBUG1 (("Supernode detected, j " ID " to j2 " ID "\n", j, j2)) ;
parent = n_col ;
p2 = pdest ;
}
}
- DEBUG1 (("Parent ["ID"] = "ID"\n", j, parent)) ;
+ DEBUG1 (("Parent [" ID "] = " ID "\n", j, parent)) ;
ASSERT (parent > j2) ;
if (parent == n_col)
}
#ifndef NDEBUG
- DEBUG3 (("\nFinal row "ID" of U after supercolumn detection:\n", j)) ;
+ DEBUG3 (("\nFinal row " ID " of U after supercolumn detection:\n", j)) ;
for (p = Up [j] ; p < pdest ; p++)
{
ASSERT (Ai [p] >= 0 && Ai [p] < n_col) ;
- DEBUG3 ((" "ID" ("ID")", Ai [p], W [Ai [p]])) ;
+ DEBUG3 ((" " ID " (" ID ")", Ai [p], W [Ai [p]])) ;
ASSERT (W [Ai [p]] == Wflag) ;
}
DEBUG3 (("\n")) ;
/* Front_parent [j] is the first column of the parent frontal matrix */
- DEBUG1 (("\n\n==== Front "ID", nfr "ID" pivot columns "ID":"ID
- " all front: "ID"-by-"ID" Parent: "ID"\n", j, nfr, j,j+npivots-1,
+ DEBUG1 (("\n\n==== Front " ID ", nfr " ID " pivot columns " ID ":" ID
+ " all front: " ID "-by-" ID " Parent: " ID "\n", j, nfr, j,j+npivots-1,
Front_nrows [j], Front_ncols [j], Front_parent [j])) ;
nfr++ ;
if (Front_npivcol [j] > 0)
{
Front_order [j] = k++ ;
- DEBUG1 (("Front order of j: "ID" is:"ID"\n", j,
+ DEBUG1 (("Front order of j: " ID " is:" ID "\n", j,
Front_order [j])) ;
}
else
k = Front_order [i] ;
if (k != EMPTY)
{
- DEBUG1 (("Front "ID" new order: "ID"\n", i, k)) ;
+ DEBUG1 (("Front " ID " new order: " ID "\n", i, k)) ;
ASSERT (k >= 0 && k < nfr) ;
ASSERT (Winv [k] == EMPTY) ;
Winv [k] = i ;
for (k = 0 ; k < nfr ; k++)
{
i = Winv [k] ;
- DEBUG1 (("Old Front "ID" New Front "ID" npivots "ID" nrows "ID
- " ncols "ID"\n",
+ DEBUG1 (("Old Front " ID " New Front " ID " npivots " ID " nrows " ID
+ " ncols " ID "\n",
i, k, Front_npivcol [i], Front_nrows [i], Front_ncols [i])) ;
ASSERT (i >= 0 && i < n_col) ;
ASSERT (Front_npivcol [i] > 0) ;
for (npiv = 0 ; npiv < Front_npivcol [i] ; npiv++)
{
Up [kk] = i + npiv ;
- DEBUG1 ((" Cperm ["ID"] = "ID"\n", kk, Up [kk])) ;
+ DEBUG1 ((" Cperm [" ID "] = " ID "\n", kk, Up [kk])) ;
kk++ ;
}
}
DEBUG1 (("\nFinal frontal matrices:\n")) ;
for (i = 0 ; i < nfr ; i++)
{
- DEBUG1 (("Final front "ID": npiv "ID" nrows "ID" ncols "ID" parent "
- ID"\n", i, Front_npivcol [i], Front_nrows [i],
+ DEBUG1 (("Final front " ID ": npiv " ID " nrows " ID " ncols " ID " parent "
+ ID "\n", i, Front_npivcol [i], Front_nrows [i],
Front_ncols [i], Front_parent [i])) ;
}
#endif
Fcblock = Work->Fcblock ;
#ifndef NDEBUG
- DEBUG6 (("SCAN2-row: "ID"\n", row)) ;
+ DEBUG6 (("SCAN2-row: " ID "\n", row)) ;
UMF_dump_rowcol (0, Numeric, Work, row, FALSE) ;
#endif
p += UNITS (Int, ncols + nrows) ;
S = ((Entry *) p) + f ;
- DEBUG6 (("Old LSON: "ID"\n", e)) ;
+ DEBUG6 (("Old LSON: " ID "\n", e)) ;
#ifndef NDEBUG
UMF_dump_element (Numeric, Work, e, FALSE) ;
#endif
ncolsleft = ep->ncolsleft ;
Frow = Fcblock + Frpos [row] ;
- DEBUG6 (("LSON found (in scan2-row): "ID"\n", e)) ;
+ DEBUG6 (("LSON found (in scan2-row): " ID "\n", e)) ;
Row_degree [row] -= ncolsleft ;
Row_tlen [row] = tp2 - tp1 ;
#ifndef NDEBUG
- DEBUG7 (("row assembled in scan2-row: "ID"\n", row)) ;
+ DEBUG7 (("row assembled in scan2-row: " ID "\n", row)) ;
UMF_dump_rowcol (0, Numeric, Work, row, FALSE) ;
DEBUG7 (("Current frontal matrix: (scan 1b)\n")) ;
UMF_dump_current_front (Numeric, Work, TRUE) ;
cdeg0 = Work->cdeg0 ;
Fcblock = Work->Fcblock ;
- DEBUG6 (("SCAN2-col: "ID"\n", col)) ;
+ DEBUG6 (("SCAN2-col: " ID "\n", col)) ;
#ifndef NDEBUG
UMF_dump_rowcol (1, Numeric, Work, col, FALSE) ;
#endif
p += UNITS (Int, ncols + nrows) ;
S = ((Entry *) p) + f * nrows ;
- DEBUG6 (("Old USON: "ID"\n", e)) ;
+ DEBUG6 (("Old USON: " ID "\n", e)) ;
#ifndef NDEBUG
UMF_dump_element (Numeric, Work, e, FALSE) ;
#endif
nrowsleft = ep->nrowsleft ;
Fcol = Fcblock + Fcpos [col] ;
- DEBUG6 (("USON found (in scan2-col): "ID"\n", e)) ;
+ DEBUG6 (("USON found (in scan2-col): " ID "\n", e)) ;
#ifndef FIXQ
Col_degree [col] -= nrowsleft ;
#endif
Col_tlen [col] = tp2 - tp1 ;
#ifndef NDEBUG
- DEBUG7 (("Column assembled in scan2-col: "ID"\n", col)) ;
+ DEBUG7 (("Column assembled in scan2-col: " ID "\n", col)) ;
UMF_dump_rowcol (1, Numeric, Work, col, FALSE) ;
DEBUG7 (("Current frontal matrix: after scan2-col\n")) ;
UMF_dump_current_front (Numeric, Work, TRUE) ;
#ifndef NDEBUG
DEBUG6 (("============================================\n")) ;
DEBUG6 (("Degree update, assembly.\n")) ;
- DEBUG6 (("pivot row pattern: fncols="ID"\n", fncols)) ;
+ DEBUG6 (("pivot row pattern: fncols=" ID "\n", fncols)) ;
for (j = 0 ; j < fncols ; j++)
{
col = Work->Fcols [j] ;
- DEBUG6 ((ID" ", col)) ;
+ DEBUG6 ((ID " ", col)) ;
ASSERT (Fcpos [col] == j * Work->fnr_curr) ;
ASSERT (NON_PIVOTAL_COL (col)) ;
}
ASSERT (Fcpos [Work->pivcol] >= 0) ;
- DEBUG6 (("pivcol: "ID" pos "ID" fnr_curr "ID" fncols "ID"\n",
+ DEBUG6 (("pivcol: " ID " pos " ID " fnr_curr " ID " fncols " ID "\n",
Work->pivcol, Fcpos [Work->pivcol], Work->fnr_curr, fncols)) ;
ASSERT (Fcpos [Work->pivcol] < fncols * Work->fnr_curr) ;
- DEBUG6 (("\npivot col pattern: fnrows="ID"\n", fnrows)) ;
+ DEBUG6 (("\npivot col pattern: fnrows=" ID "\n", fnrows)) ;
for (i = 0 ; i < fnrows ; i++)
{
row = Work->Frows [i] ;
- DEBUG6 ((ID" ", row)) ;
+ DEBUG6 ((ID " ", row)) ;
ASSERT (Frpos [row] == i) ;
ASSERT (NON_PIVOTAL_ROW (row)) ;
}
/* assemble from prior elements into the current frontal matrix */
/* ---------------------------------------------------------------------- */
- DEBUG2 (("New assemble start [prior_element:"ID"\n", Work->prior_element)) ;
+ DEBUG2 (("New assemble start [prior_element:" ID "\n", Work->prior_element)) ;
/* Currently no rows or columns are marked. No elements are scanned, */
/* that is, (ep->next == EMPTY) is true for all elements */
ep->next = son_list ;
son_list = e ;
#ifndef NDEBUG
- DEBUG2 (("e "ID" is Prior son "ID" "ID"\n",
+ DEBUG2 (("e " ID " is Prior son " ID " " ID "\n",
e, prior_Uson, prior_Lson)) ;
UMF_dump_element (Numeric, Work, e, FALSE) ;
#endif
if (row < 0) row = FLIP (row) ;
ASSERT (row >= 0 && row < n_row) ;
- DEBUG6 (("SCAN1-row: "ID"\n", row)) ;
+ DEBUG6 (("SCAN1-row: " ID "\n", row)) ;
#ifndef NDEBUG
UMF_dump_rowcol (0, Numeric, Work, row, FALSE) ;
#endif
{
/* first time seen in scan1-row */
ep->cdeg = ep->nrowsleft + cdeg0 ;
- DEBUG6 (("e "ID" First seen: cdeg: "ID" ", e, ep->cdeg-cdeg0)) ;
+ DEBUG6 (("e " ID " First seen: cdeg: " ID " ", e, ep->cdeg-cdeg0)) ;
ASSERT (ep->ncolsleft > 0 && ep->nrowsleft > 0) ;
}
ep->cdeg-- ; /* decrement external column degree */
- DEBUG6 (("e "ID" New ext col deg: "ID"\n", e, ep->cdeg - cdeg0)) ;
+ DEBUG6 (("e " ID " New ext col deg: " ID "\n", e, ep->cdeg - cdeg0)) ;
/* this element is not yet in the new son list */
if (ep->cdeg == cdeg0 && ep->next == EMPTY)
if (col < 0) col = FLIP (col) ;
ASSERT (col >= 0 && col < n_col) ;
- DEBUG6 (("SCAN 1-col: "ID"\n", col)) ;
+ DEBUG6 (("SCAN 1-col: " ID "\n", col)) ;
#ifndef NDEBUG
UMF_dump_rowcol (1, Numeric, Work, col, FALSE) ;
#endif
{
/* first time seen in scan1-col */
ep->rdeg = ep->ncolsleft + rdeg0 ;
- DEBUG6 (("e "ID" First seen: rdeg: "ID" ", e, ep->rdeg-rdeg0)) ;
+ DEBUG6 (("e " ID " First seen: rdeg: " ID " ", e, ep->rdeg-rdeg0)) ;
ASSERT (ep->ncolsleft > 0 && ep->nrowsleft > 0) ;
}
ep->rdeg-- ; /* decrement external row degree */
- DEBUG6 (("e "ID" New ext row degree: "ID"\n", e, ep->rdeg-rdeg0)) ;
+ DEBUG6 (("e " ID " New ext row degree: " ID "\n", e, ep->rdeg-rdeg0)) ;
if (ep->rdeg == rdeg0 && ep->next == EMPTY)
{
{
ASSERT (e > 0 && e <= Work->nel && E [e]) ;
p = Memory + E [e] ;
- DEBUG2 (("New son: "ID"\n", e)) ;
+ DEBUG2 (("New son: " ID "\n", e)) ;
#ifndef NDEBUG
UMF_dump_element (Numeric, Work, e, FALSE) ;
#endif
extcdeg = (ep->cdeg < cdeg0) ? nrowsleft : (ep->cdeg - cdeg0) ;
ncols_to_assemble = ncolsleft - extrdeg ;
nrows_to_assemble = nrowsleft - extcdeg ;
- DEBUG2 (("extrdeg "ID" extcdeg "ID"\n", extrdeg, extcdeg)) ;
+ DEBUG2 (("extrdeg " ID " extcdeg " ID "\n", extrdeg, extcdeg)) ;
if (extrdeg == 0 && extcdeg == 0)
{
/* this is an LUson - assemble an entire contribution block */
/* -------------------------------------------------------------- */
- DEBUG6 (("LUson found: "ID"\n", e)) ;
+ DEBUG6 (("LUson found: " ID "\n", e)) ;
if (nrows == nrowsleft)
{
/* this is a Uson - assemble all possible columns */
/* -------------------------------------------------------------- */
- DEBUG6 (("New USON: "ID"\n", e)) ;
+ DEBUG6 (("New USON: " ID "\n", e)) ;
ASSERT (extrdeg > 0) ;
- DEBUG6 (("New uson "ID" cols to do "ID"\n", e, ncols_to_assemble)) ;
+ DEBUG6 (("New uson " ID " cols to do " ID "\n", e, ncols_to_assemble)) ;
if (ncols_to_assemble > 0)
{
/* this is an Lson - assemble all possible rows */
/* -------------------------------------------------------------- */
- DEBUG6 (("New LSON: "ID"\n", e)) ;
+ DEBUG6 (("New LSON: " ID "\n", e)) ;
ASSERT (extrdeg == 0 && extcdeg > 0) ;
- DEBUG6 (("New lson "ID" rows to do "ID"\n", e, nrows_to_assemble)) ;
+ DEBUG6 (("New lson " ID " rows to do " ID "\n", e, nrows_to_assemble)) ;
if (nrows_to_assemble > 0)
{
row = Work->Frows [i2] ;
ASSERT (row >= 0 && row < n_row) ;
- DEBUG6 (("DEBUG SCAN 1: "ID"\n", row)) ;
+ DEBUG6 (("DEBUG SCAN 1: " ID "\n", row)) ;
UMF_dump_rowcol (0, Numeric, Work, row, TRUE) ;
ASSERT (NON_PIVOTAL_ROW (row)) ;
extrdeg = (ep->rdeg < rdeg0) ? ep->ncolsleft : (ep->rdeg - rdeg0) ;
extcdeg = (ep->cdeg < cdeg0) ? ep->nrowsleft : (ep->cdeg - cdeg0) ;
DEBUG6 ((
- "e "ID" After assembly ext row deg: "ID" ext col degree "ID"\n",
+ "e " ID " After assembly ext row deg: " ID " ext col degree " ID "\n",
e, extrdeg, extcdeg)) ;
if (Work->any_skip)
col = Work->Fcols [j2] ;
ASSERT (col >= 0 && col < n_col) ;
- DEBUG6 (("DEBUG SCAN 2: "ID"\n", col)) ;
+ DEBUG6 (("DEBUG SCAN 2: " ID "\n", col)) ;
#ifndef FIXQ
UMF_dump_rowcol (1, Numeric, Work, col, TRUE) ;
#else
ASSERT (col == Cols [f]) ;
extrdeg = (ep->rdeg < rdeg0) ? ep->ncolsleft : (ep->rdeg - rdeg0) ;
extcdeg = (ep->cdeg < cdeg0) ? ep->nrowsleft : (ep->cdeg - cdeg0) ;
- DEBUG6 (("e "ID" After assembly ext col deg: "ID"\n", e, extcdeg)) ;
+ DEBUG6 (("e " ID " After assembly ext col deg: " ID "\n", e, extcdeg)) ;
if (Work->any_skip)
{
#define blas_ok FALSE
#endif
- DEBUG5 (("In UMF_blas3_update "ID" "ID" "ID"\n",
+ DEBUG5 (("In UMF_blas3_update " ID " " ID " " ID "\n",
Work->fnpiv, Work->fnrows, Work->fncols)) ;
k = Work->fnpiv ;
#ifndef NDEBUG
DEBUG5 (("DO RANK-NB UPDATE of frontal:\n")) ;
- DEBUG5 (("DGEMM : "ID" "ID" "ID"\n", k, m, n)) ;
+ DEBUG5 (("DGEMM : " ID " " ID " " ID "\n", k, m, n)) ;
DEBUG7 (("C block: ")) ; UMF_dump_dense (C, d, m, n) ;
DEBUG7 (("A block: ")) ; UMF_dump_dense (L, d, m, k) ;
DEBUG7 (("B' block: ")) ; UMF_dump_dense (U, dc, n, k) ;
#ifndef NDEBUG
DEBUG5 (("RANK-NB UPDATE of frontal done:\n")) ;
- DEBUG5 (("DGEMM : "ID" "ID" "ID"\n", k, m, n)) ;
+ DEBUG5 (("DGEMM : " ID " " ID " " ID "\n", k, m, n)) ;
DEBUG7 (("C block: ")) ; UMF_dump_dense (C, d, m, n) ;
DEBUG7 (("A block: ")) ; UMF_dump_dense (L, d, m, k) ;
DEBUG7 (("B' block: ")) ; UMF_dump_dense (U, dc, n, k) ;
DEBUG7 (("LU block: ")) ; UMF_dump_dense (LU, nb, k, k) ;
#endif
- DEBUG2 (("blas3 "ID" "ID" "ID"\n", k, Work->fnrows, Work->fncols)) ;
+ DEBUG2 (("blas3 " ID " " ID " " ID "\n", k, Work->fnrows, Work->fncols)) ;
}
nel = Work->nel ;
n1 = Work->n1 ;
- DEBUG3 (("BUILD_TUPLES: n_row "ID" n_col "ID" nel "ID"\n",
+ DEBUG3 (("BUILD_TUPLES: n_row " ID " n_col " ID " nel " ID "\n",
n_row, n_col, nel)) ;
/* ---------------------------------------------------------------------- */
/* for all elements, in order of creation */
for (e = 1 ; e <= nel ; e++)
{
- DEBUG9 (("Adding tuples for element: "ID" at "ID"\n", e, E [e])) ;
+ DEBUG9 (("Adding tuples for element: " ID " at " ID "\n", e, E [e])) ;
ASSERT (E [e]) ; /* no external fragmentation */
p = Numeric->Memory + E [e] ;
GET_ELEMENT_PATTERN (ep, p, Cols, Rows, ncols) ;
if (n_row < 0) /* n_row must be >= 0 */
{
/* UMFPACK: does not call UMF_colamd if n <= 0 */
- DEBUG0 (("colamd: nrow negative "ID"\n", n_row)) ;
+ DEBUG0 (("colamd: nrow negative " ID "\n", n_row)) ;
stats [COLAMD_STATUS] = COLAMD_ERROR_nrow_negative ;
stats [COLAMD_INFO1] = n_row ;
return (FALSE) ;
if (n_col < 0) /* n_col must be >= 0 */
{
/* UMFPACK: does not call UMF_colamd if n <= 0 */
- DEBUG0 (("colamd: ncol negative "ID"\n", n_col)) ;
+ DEBUG0 (("colamd: ncol negative " ID "\n", n_col)) ;
stats [COLAMD_STATUS] = COLAMD_ERROR_ncol_negative ;
stats [COLAMD_INFO1] = n_col ;
return (FALSE) ;
if (nnz < 0) /* nnz must be >= 0 */
{
/* UMFPACK: does not call UMF_colamd if nnz < 0 */
- DEBUG0 (("colamd: number of entries negative "ID"\n", nnz)) ;
+ DEBUG0 (("colamd: number of entries negative " ID "\n", nnz)) ;
stats [COLAMD_STATUS] = COLAMD_ERROR_nnz_negative ;
stats [COLAMD_INFO1] = nnz ;
return (FALSE) ;
if (p [0] != 0) /* p [0] must be exactly zero */
{
- DEBUG0 (("colamd: p[0] not zero "ID"\n", p [0])) ;
+ DEBUG0 (("colamd: p[0] not zero " ID "\n", p [0])) ;
stats [COLAMD_STATUS] = COLAMD_ERROR_p0_nonzero ;
stats [COLAMD_INFO1] = p [0] ;
return (FALSE) ;
{
/* UMFPACK: always passes enough space */
/* not enough space in array A to perform the ordering */
- DEBUG0 (("colamd: Need Alen >= "ID", given only Alen = "ID"\n",
+ DEBUG0 (("colamd: Need Alen >= " ID ", given only Alen = " ID "\n",
need, Alen)) ;
stats [COLAMD_STATUS] = COLAMD_ERROR_A_too_small ;
stats [COLAMD_INFO1] = need ;
for (col = Front_cols [i] ; col != EMPTY ; col = Col [col].nextcol)
{
ASSERT (col >= 0 && col < n_col) ;
- DEBUG1 (("Colamd output ordering: k "ID" col "ID"\n", k, col)) ;
+ DEBUG1 (("Colamd output ordering: k " ID " col " ID "\n", k, col)) ;
p [k] = col ;
ASSERT (A [col] == EMPTY) ;
A [col] = k ;
{
k = Col [col].shared2.order ;
ASSERT (k >= n_col2 && k < n_col) ;
- DEBUG1 (("Colamd output ordering: k "ID" col "ID
+ DEBUG1 (("Colamd output ordering: k " ID " col " ID
" (dense or null col)\n", k, col)) ;
p [k] = col ;
A [col] = k ;
stats [COLAMD_STATUS] = COLAMD_ERROR_col_length_negative ;
stats [COLAMD_INFO1] = col ;
stats [COLAMD_INFO2] = Col [col].length ;
- DEBUG0 (("colamd: col "ID" length "ID" <= 0\n",
+ DEBUG0 (("colamd: col " ID " length " ID " <= 0\n",
col, Col [col].length));
return (FALSE) ;
}
/* not needed in UMFPACK: */
/* stats [COLAMD_INFO3] = n_row ; */
/* ------------------ */
- DEBUG0 (("colamd: row "ID" col "ID" out of bounds\n", row,col));
+ DEBUG0 (("colamd: row " ID " col " ID " out of bounds\n", row,col));
return (FALSE) ;
}
#endif
stats [COLAMD_STATUS] = COLAMD_ERROR_jumbled_matrix ;
stats [COLAMD_INFO1] = col ;
stats [COLAMD_INFO2] = row ;
- DEBUG1 (("colamd: row "ID" col "ID" unsorted/duplicate\n",
+ DEBUG1 (("colamd: row " ID " col " ID " unsorted/duplicate\n",
row, col)) ;
return (FALSE) ;
}
dense_col_count = MAX (0, MIN (dense_col_count, n_row)) ;
/* --------------------- */
- DEBUG1 (("colamd: densecount: "ID" "ID"\n",
+ DEBUG1 (("colamd: densecount: " ID " " ID "\n",
dense_row_count, dense_col_count)) ;
max_deg = 0 ;
n_col2 = n_col ;
/* --------------------- */
}
}
- DEBUG1 (("colamd: null columns killed: "ID"\n", n_col - n_col2)) ;
+ DEBUG1 (("colamd: null columns killed: " ID "\n", n_col - n_col2)) ;
#endif
#ifndef NDEBUG
KILL_PRINCIPAL_COL (c) ;
}
}
- DEBUG1 (("colamd: Dense and null columns killed: "ID"\n", n_col - n_col2)) ;
+ DEBUG1 (("colamd: Dense and null columns killed: " ID "\n", n_col - n_col2)) ;
/* === Kill dense and empty rows ======================================== */
}
}
nnewlyempty_row = ne - nempty_row ;
- DEBUG1 (("colamd: Dense rows killed: "ID"\n", ndense_row)) ;
- DEBUG1 (("colamd: Dense and null rows killed: "ID"\n", n_row - n_row2)) ;
+ DEBUG1 (("colamd: Dense rows killed: " ID "\n", ndense_row)) ;
+ DEBUG1 (("colamd: Dense and null rows killed: " ID "\n", n_row - n_row2)) ;
/* === Compute initial column scores ==================================== */
{
/* a newly-made null column (all rows in this col are "dense" */
/* and have already been killed) */
- DEBUG2 (("Newly null killed: "ID"\n", c)) ;
+ DEBUG2 (("Newly null killed: " ID "\n", c)) ;
Col [c].shared2.order = --n_col2 ;
KILL_PRINCIPAL_COL (c) ;
/* --------------------- */
Col [c].shared2.score = score ;
}
}
- DEBUG1 (("colamd: Dense, null, and newly-null columns killed: "ID"\n",
+ DEBUG1 (("colamd: Dense, null, and newly-null columns killed: " ID "\n",
n_col-n_col2)) ;
/* At this point, all empty rows and columns are dead. All live columns */
/* only add principal columns to degree lists */
if (COL_IS_ALIVE (c))
{
- DEBUG4 (("place "ID" score "ID" minscore "ID" ncol "ID"\n",
+ DEBUG4 (("place " ID " score " ID " minscore " ID " ncol " ID "\n",
c, Col [c].shared2.score, min_score, n_col)) ;
/* === Add columns score to DList =============================== */
}
#ifndef NDEBUG
- DEBUG1 (("colamd: Live cols "ID" out of "ID", non-princ: "ID"\n",
+ DEBUG1 (("colamd: Live cols " ID " out of " ID ", non-princ: " ID "\n",
debug_count, n_col, n_col-debug_count)) ;
ASSERT (debug_count == n_col2) ;
debug_deg_lists (n_row, n_col, Row, Col, head, min_score, n_col2, max_deg) ;
tag_mark = clear_mark (n_row, Row) ;
min_score = 0 ;
ngarbage = 0 ;
- DEBUG1 (("colamd: Ordering, n_col2="ID"\n", n_col2)) ;
+ DEBUG1 (("colamd: Ordering, n_col2=" ID "\n", n_col2)) ;
for (row = 0 ; row < n_row ; row++)
{
#ifndef NDEBUG
if (debug_step % 100 == 0)
{
- DEBUG2 (("\n... Step k: "ID" out of n_col2: "ID"\n", k, n_col2)) ;
+ DEBUG2 (("\n... Step k: " ID " out of n_col2: " ID "\n", k, n_col2)) ;
}
else
{
- DEBUG3 (("\n-----Step k: "ID" out of n_col2: "ID"\n", k, n_col2)) ;
+ DEBUG3 (("\n-----Step k: " ID " out of n_col2: " ID "\n", k, n_col2)) ;
}
debug_step++ ;
debug_deg_lists (n_row, n_col, Row, Col, head,
}
ASSERT (COL_IS_ALIVE (pivot_col)) ;
- DEBUG3 (("Pivot col: "ID"\n", pivot_col)) ;
+ DEBUG3 (("Pivot col: " ID "\n", pivot_col)) ;
/* remember score for defrag check */
pivot_col_score = Col [pivot_col].shared2.score ;
{
/* get a row */
row = *cp++ ;
- DEBUG4 (("Pivot col pattern %d "ID"\n", ROW_IS_ALIVE(row), row)) ;
+ DEBUG4 (("Pivot col pattern %d " ID "\n", ROW_IS_ALIVE(row), row)) ;
/* skip if row is dead */
if (ROW_IS_DEAD (row))
{
pivot_row_degree += col_thickness ;
/* ------------------ */
/* added for UMFPACK: */
- DEBUG4 (("\t\t\tNew live column in pivot row: "ID"\n",col));
+ DEBUG4 (("\t\t\tNew live column in pivot row: " ID "\n",col));
/* ------------------ */
}
/* ------------------ */
#ifndef NDEBUG
if (col_thickness < 0 && COL_IS_ALIVE (col))
{
- DEBUG4 (("\t\t\tOld live column in pivot row: "ID"\n",col));
+ DEBUG4 (("\t\t\tOld live column in pivot row: " ID "\n",col));
}
#endif
/* ------------------ */
/* may be killing an already dead row */
row = *cp++ ;
- DEBUG2 (("Kill row in pivot col: "ID" alive? %d, front "ID"\n",
+ DEBUG2 (("Kill row in pivot col: " ID " alive? %d, front " ID "\n",
row, ROW_IS_ALIVE (row), Row [row].front)) ;
/* added for UMFPACK: */
/* Row [row].front is a child of current front */
child = Row [row].front ;
Front_parent [child] = nfr ;
- DEBUG1 (("Front "ID" => front "ID", normal\n", child, nfr));
+ DEBUG1 (("Front " ID " => front " ID ", normal\n", child, nfr));
}
else
{
/* This is an original row. Keep track of which front
* is its parent in the row-merge tree. */
InFront [row] = nfr ;
- DEBUG1 (("Row "ID" => front "ID", normal\n", row, nfr)) ;
+ DEBUG1 (("Row " ID " => front " ID ", normal\n", row, nfr)) ;
}
}
{
/* pick the "pivot" row arbitrarily (first row in col) */
pivot_row = A [Col [pivot_col].start] ;
- DEBUG3 (("Pivotal row is "ID"\n", pivot_row)) ;
+ DEBUG3 (("Pivotal row is " ID "\n", pivot_row)) ;
}
else
{
{
col = *rp++ ;
ASSERT (COL_IS_ALIVE (col) && col != pivot_col) ;
- DEBUG3 ((" Col: "ID"\n", col)) ;
+ DEBUG3 ((" Col: " ID "\n", col)) ;
/* clear tags used to construct pivot row pattern */
col_thickness = -Col [col].shared1.thickness ;
if (set_difference == 0 && aggressive)
{
/* v4.1: do aggressive absorption */
- DEBUG3 (("aggressive absorption. Row: "ID"\n", row)) ;
+ DEBUG3 (("aggressive absorption. Row: " ID "\n", row)) ;
if (Row [row].front != EMPTY)
{
/* Row [row].front is a child of current front. */
child = Row [row].front ;
Front_parent [child] = nfr ;
- DEBUG1 (("Front "ID" => front "ID", aggressive\n",
+ DEBUG1 (("Front " ID " => front " ID ", aggressive\n",
child, nfr)) ;
}
else
/* this is an original row. Keep track of which front
* assembles it, for the row-merge tree */
InFront [row] = nfr ;
- DEBUG1 (("Row "ID" => front "ID", aggressive\n",
+ DEBUG1 (("Row " ID " => front " ID ", aggressive\n",
row, nfr)) ;
}
new_cp = cp ;
cp_end = cp + Col [col].length ;
- DEBUG4 (("Adding set diffs for Col: "ID".\n", col)) ;
+ DEBUG4 (("Adding set diffs for Col: " ID ".\n", col)) ;
while (cp < cp_end)
{
{
/* ------------------ */
/* changed for UMFPACK: */
- DEBUG4 ((" Row "ID", dead\n", row)) ;
+ DEBUG4 ((" Row " ID ", dead\n", row)) ;
/* ------------------ */
continue ;
}
/* ------------------ */
/* changed for UMFPACK: */
/* ASSERT (row_mark > tag_mark) ; */
- DEBUG4 ((" Row "ID", set diff "ID"\n", row, row_mark-tag_mark));
+ DEBUG4 ((" Row " ID ", set diff " ID "\n", row, row_mark-tag_mark));
ASSERT (row_mark >= tag_mark) ;
/* ------------------ */
/* compact the column */
if (Col [col].length == 0)
{
- DEBUG4 (("further mass elimination. Col: "ID"\n", col)) ;
+ DEBUG4 (("further mass elimination. Col: " ID "\n", col)) ;
/* nothing left but the pivot row in this column */
KILL_PRINCIPAL_COL (col) ;
pivot_row_degree -= Col [col].shared1.thickness ;
{
/* === Prepare for supercolumn detection ==================== */
- DEBUG4 (("Preparing supercol detection for Col: "ID".\n", col));
+ DEBUG4 (("Preparing supercol detection for Col: " ID ".\n", col));
/* save score so far */
Col [col].shared2.score = cur_score ;
* this problem is avoided. */
hash %= n_col + 1 ;
- DEBUG4 ((" Hash = "ID", n_col = "ID".\n", (Int) hash, n_col)) ;
+ DEBUG4 ((" Hash = " ID ", n_col = " ID ".\n", (Int) hash, n_col)) ;
ASSERT (((Int) hash) <= n_col) ;
head_column = head [hash] ;
/* === Finalize the new pivot row, and column scores ================ */
DEBUG3 (("** Finalize scores phase. **\n")) ;
- DEBUG3 (("pivot_row_degree "ID"\n", pivot_row_degree)) ;
+ DEBUG3 (("pivot_row_degree " ID "\n", pivot_row_degree)) ;
/* for each column in pivot row */
rp = &A [pivot_row_start] ;
while (rp < rp_end)
{
col = *rp++ ;
- DEBUG3 (("Col "ID" \n", col)) ;
+ DEBUG3 (("Col " ID " \n", col)) ;
/* skip dead columns */
if (COL_IS_DEAD (col))
{
/* (we wait until here for this in case the pivot */
/* row's degree was reduced due to mass elimination). */
cur_score = Col [col].shared2.score + pivot_row_degree ;
- DEBUG3 ((" cur_score "ID" ", cur_score)) ;
+ DEBUG3 ((" cur_score " ID " ", cur_score)) ;
/* calculate the max possible score as the number of */
/* external columns minus the 'k' value minus the */
/* columns thickness */
max_score = n_col - k - Col [col].shared1.thickness ;
- DEBUG3 ((" max_score "ID" ", max_score)) ;
+ DEBUG3 ((" max_score " ID " ", max_score)) ;
/* make the score the external degree of the union-of-rows */
cur_score -= Col [col].shared1.thickness ;
- DEBUG3 ((" cur_score "ID" ", cur_score)) ;
+ DEBUG3 ((" cur_score " ID " ", cur_score)) ;
/* make sure score is less or equal than the max score */
cur_score = MIN (cur_score, max_score) ;
/* store updated score */
Col [col].shared2.score = cur_score ;
- DEBUG3 ((" "ID"\n", cur_score)) ;
+ DEBUG3 ((" " ID "\n", cur_score)) ;
/* === Place column back in degree list ========================= */
Front_parent [nfr] = EMPTY ;
pivot_row_thickness -= pivot_col_thickness ;
- DEBUG1 (("Front "ID" Pivot_row_thickness after pivot cols elim: "ID"\n",
+ DEBUG1 (("Front " ID " Pivot_row_thickness after pivot cols elim: " ID "\n",
nfr, pivot_row_thickness)) ;
pivot_row_thickness = MAX (0, pivot_row_thickness) ;
/* ------------------ */
/* added for UMFPACK: */
#ifndef NDEBUG
- DEBUG1 (("Front "ID" : "ID" "ID" "ID" ", nfr,
+ DEBUG1 (("Front " ID " : " ID " " ID " " ID " ", nfr,
Front_npivcol [nfr], Front_nrows [nfr], Front_ncols [nfr])) ;
DEBUG1 ((" cols:[ ")) ;
debug_d = 0 ;
for (col = Front_cols [nfr] ; col != EMPTY ; col = Col [col].nextcol)
{
- DEBUG1 ((" "ID, col)) ;
+ DEBUG1 ((" " ID, col)) ;
ASSERT (col >= 0 && col < n_col) ;
ASSERT (COL_IS_DEAD (col)) ;
debug_d++ ;
{
len = Col [c].length ;
score = Col [c].shared2.score ;
- DEBUG4 (("initial live col "ID" "ID" "ID"\n", c, len, score)) ;
+ DEBUG4 (("initial live col " ID " " ID " " ID "\n", c, len, score)) ;
ASSERT (len > 0) ;
ASSERT (score >= 0) ;
ASSERT (Col [c].shared1.thickness == 1) ;
return ;
}
have = 0 ;
- DEBUG4 (("Degree lists: "ID"\n", min_score)) ;
+ DEBUG4 (("Degree lists: " ID "\n", min_score)) ;
for (deg = 0 ; deg <= n_col ; deg++)
{
col = head [deg] ;
{
continue ;
}
- DEBUG4 ((ID":", deg)) ;
+ DEBUG4 ((ID ":", deg)) ;
while (col != EMPTY)
{
- DEBUG4 ((" "ID, col)) ;
+ DEBUG4 ((" " ID, col)) ;
have += Col [col].shared1.thickness ;
ASSERT (COL_IS_ALIVE (col)) ;
col = Col [col].shared4.degree_next ;
}
DEBUG4 (("\n")) ;
}
- DEBUG4 (("should "ID" have "ID"\n", should, have)) ;
+ DEBUG4 (("should " ID " have " ID "\n", should, have)) ;
ASSERT (should == have) ;
/* === Check the row degrees ============================================ */
DEBUG3 (("DUMP MATRIX:\n")) ;
for (r = 0 ; r < n_row ; r++)
{
- DEBUG3 (("Row "ID" alive? %d\n", r, ROW_IS_ALIVE (r))) ;
+ DEBUG3 (("Row " ID " alive? %d\n", r, ROW_IS_ALIVE (r))) ;
if (ROW_IS_DEAD (r))
{
continue ;
/* ------------------ */
/* changed for UMFPACK: */
- DEBUG3 (("start "ID" length "ID" degree "ID" thickness "ID"\n",
+ DEBUG3 (("start " ID " length " ID " degree " ID " thickness " ID "\n",
Row [r].start, Row [r].length, Row [r].shared1.degree,
Row [r].thickness)) ;
/* ------------------ */
while (rp < rp_end)
{
c = *rp++ ;
- DEBUG4 ((" %d col "ID"\n", COL_IS_ALIVE (c), c)) ;
+ DEBUG4 ((" %d col " ID "\n", COL_IS_ALIVE (c), c)) ;
}
}
for (c = 0 ; c < n_col ; c++)
{
- DEBUG3 (("Col "ID" alive? %d\n", c, COL_IS_ALIVE (c))) ;
+ DEBUG3 (("Col " ID " alive? %d\n", c, COL_IS_ALIVE (c))) ;
if (COL_IS_DEAD (c))
{
continue ;
}
/* ------------------ */
/* changed for UMFPACK: */
- DEBUG3 (("start "ID" length "ID" shared1[thickness,parent] "ID
- " shared2 [order,score] "ID"\n", Col [c].start, Col [c].length,
+ DEBUG3 (("start " ID " length " ID " shared1[thickness,parent] " ID
+ " shared2 [order,score] " ID "\n", Col [c].start, Col [c].length,
Col [c].shared1.thickness, Col [c].shared2.score));
/* ------------------ */
cp = &A [Col [c].start] ;
while (cp < cp_end)
{
r = *cp++ ;
- DEBUG4 ((" %d row "ID"\n", ROW_IS_ALIVE (r), r)) ;
+ DEBUG4 ((" %d row " ID "\n", ROW_IS_ALIVE (r), r)) ;
}
/* ------------------ */
ncols = 0 ;
for (col = super_c ; col != EMPTY ; col = Col [col].nextcol)
{
- DEBUG1 ((" "ID, col)) ;
+ DEBUG1 ((" " ID, col)) ;
ASSERT (col >= 0 && col < n_col) ;
if (col != super_c)
{
e = ++(Work->nel) ; /* get the name of this new frontal matrix */
Work->prior_element = e ;
- DEBUG8 (("wrapup e "ID" nel "ID"\n", e, Work->nel)) ;
+ DEBUG8 (("wrapup e " ID " nel " ID "\n", e, Work->nel)) ;
ASSERT (e > 0 && e < Work->elen) ;
ASSERT (E [e] == 0) ;
Cols [i] = Fcols [i] ;
}
Fcol = Work->Fcblock ;
- DEBUG0 (("copy front "ID" by "ID"\n", fnrows, fncols)) ;
+ DEBUG0 (("copy front " ID " by " ID "\n", fnrows, fncols)) ;
fnr_curr = Work->fnr_curr ;
ASSERT (fnr_curr >= 0 && fnr_curr % 2 == 1) ;
for (j = 0 ; j < fncols ; j++)
ASSERT (col >= 0 && col < n_col) ;
ASSERT (NON_PIVOTAL_COL (col)) ;
t1 = Col_tuples [col] ;
- DEBUG1 (("Placing on col:"ID" , tuples at "ID"\n",
+ DEBUG1 (("Placing on col:" ID " , tuples at " ID "\n",
col, Col_tuples [col])) ;
size = 0 ;
}
needunits = UNITS (Tuple, len + 1) ;
- DEBUG1 (("len: "ID" size: "ID" needunits: "ID"\n",
+ DEBUG1 (("len: " ID " size: " ID " needunits: " ID "\n",
len, size, needunits));
if (needunits > size && t1)
if (needunits > size)
{
/* no room exists - reallocate elsewhere */
- DEBUG1 (("REALLOCATE Col: "ID", size "ID" to "ID"\n",
+ DEBUG1 (("REALLOCATE Col: " ID ", size " ID " to " ID "\n",
col, size, 2*needunits)) ;
#ifndef NDEBUG
ASSERT (row >= 0 && row < n_row) ;
ASSERT (NON_PIVOTAL_ROW (row)) ;
t1 = Row_tuples [row] ;
- DEBUG1 (("Placing on row:"ID" , tuples at "ID"\n",
+ DEBUG1 (("Placing on row:" ID " , tuples at " ID "\n",
row, Row_tuples [row])) ;
size = 0 ;
}
needunits = UNITS (Tuple, len + 1) ;
- DEBUG1 (("len: "ID" size: "ID" needunits: "ID"\n",
+ DEBUG1 (("len: " ID " size: " ID " needunits: " ID "\n",
len, size, needunits)) ;
if (needunits > size && t1)
if (needunits > size)
{
/* no room exists - reallocate elsewhere */
- DEBUG1 (("REALLOCATE Row: "ID", size "ID" to "ID"\n",
+ DEBUG1 (("REALLOCATE Row: " ID ", size " ID " to " ID "\n",
row, size, 2*needunits)) ;
#ifndef NDEBUG
/* ---------------------------------------------------------------------- */
#ifndef NDEBUG
- DEBUG1 (("Done extending\nFINAL: element row pattern: len="ID"\n", fncols));
- for (j = 0 ; j < fncols ; j++) DEBUG1 ((""ID"\n", Fcols [j])) ;
- DEBUG1 (("FINAL: element col pattern: len="ID"\n", fnrows)) ;
- for (j = 0 ; j < fnrows ; j++) DEBUG1 ((""ID"\n", Frows [j])) ;
+ DEBUG1 (("Done extending\nFINAL: element row pattern: len=" ID "\n", fncols));
+ for (j = 0 ; j < fncols ; j++) DEBUG1 (("" ID "\n", Fcols [j])) ;
+ DEBUG1 (("FINAL: element col pattern: len=" ID "\n", fnrows)) ;
+ for (j = 0 ; j < fnrows ; j++) DEBUG1 (("" ID "\n", Frows [j])) ;
for (j = 0 ; j < fncols ; j++)
{
col = Fcols [j] ;
{
UMF_dump_memory (Numeric) ;
}
- DEBUG1 (("New element, after filling with stuff: "ID"\n", e)) ;
+ DEBUG1 (("New element, after filling with stuff: " ID "\n", e)) ;
UMF_dump_element (Numeric, Work, e, TRUE) ;
if (nn < 1000)
{
- DEBUG4 (("Matrix dump, after New element: "ID"\n", e)) ;
+ DEBUG4 (("Matrix dump, after New element: " ID "\n", e)) ;
UMF_dump_matrix (Numeric, Work, TRUE) ;
}
DEBUG3 (("FRONTAL WRAPUP DONE\n")) ;
DEBUG7 (("No dense matrix allocated\n")) ;
return ;
}
- DEBUG8 ((" dimension= "ID" rows= "ID" cols= "ID"\n", dim, m, n)) ;
+ DEBUG8 ((" dimension= " ID " rows= " ID " cols= " ID "\n", dim, m, n)) ;
for (i = 0 ; i < m ; i++)
{
- DEBUG9 ((ID": ", i)) ;
+ DEBUG9 ((ID ": ", i)) ;
for (j = 0 ; j < n ; j++)
{
EDEBUG9 (C [i+j*dim]) ;
return ;
}
- DEBUG7 (("\n====================ELEMENT: "ID" ", e)) ;
+ DEBUG7 (("\n====================ELEMENT: " ID " ", e)) ;
if (!Numeric || !Work || !Numeric->Memory)
{
DEBUG7 ((" No Numeric, Work\n")) ;
return ;
}
- DEBUG7 ((" nel: "ID" of "ID, e, Work->nel)) ;
+ DEBUG7 ((" nel: " ID " of " ID, e, Work->nel)) ;
E = Work->E ;
if (!E)
{
Row_degree = Numeric->Rperm ;
p = Numeric->Memory + E [e] ;
- DEBUG7 (("ep "ID"\n", (Int) (p-Numeric->Memory))) ;
+ DEBUG7 (("ep " ID "\n", (Int) (p-Numeric->Memory))) ;
GET_ELEMENT (ep, p, Cols, Rows, ncols, nrows, C) ;
- DEBUG7 (("nrows "ID" nrowsleft "ID"\n", nrows, ep->nrowsleft)) ;
- DEBUG7 (("ncols "ID" ncolsleft "ID"\n", ncols, ep->ncolsleft)) ;
- DEBUG7 (("cdeg-cdeg0 "ID" rdeg-rdeg0 "ID" next "ID"\n",
+ DEBUG7 (("nrows " ID " nrowsleft " ID "\n", nrows, ep->nrowsleft)) ;
+ DEBUG7 (("ncols " ID " ncolsleft " ID "\n", ncols, ep->ncolsleft)) ;
+ DEBUG7 (("cdeg-cdeg0 " ID " rdeg-rdeg0 " ID " next " ID "\n",
ep->cdeg - Work->cdeg0, ep->rdeg - Work->rdeg0, ep->next)) ;
DEBUG8 (("rows: ")) ;
row = Rows [i] ;
if (row >= 0)
{
- DEBUG8 ((" "ID, row)) ;
+ DEBUG8 ((" " ID, row)) ;
ASSERT (row < Work->n_row) ;
if ((k++ % 10) == 9) DEBUG8 (("\n")) ;
ASSERT (IMPLIES (clean, NON_PIVOTAL_ROW (row))) ;
col = Cols [j] ;
if (col >= 0)
{
- DEBUG8 ((" "ID, col)) ;
+ DEBUG8 ((" " ID, col)) ;
ASSERT (col < Work->n_col) ;
if ((k++ % 10) == 9) DEBUG8 (("\n")) ;
ASSERT (IMPLIES (clean, NON_PIVOTAL_COL (col))) ;
row = Rows [i] ;
if (row >= 0)
{
- DEBUG9 ((ID": ", row)) ;
+ DEBUG9 ((ID ": ", row)) ;
k = 0 ;
for (j = 0 ; j < ep->ncols ; j++)
{
if (dumpwhich == 0)
{
- DEBUG7 (("\n====================ROW: "ID, dumpindex)) ;
+ DEBUG7 (("\n====================ROW: " ID, dumpindex)) ;
}
else
{
- DEBUG7 (("\n====================COL: "ID, dumpindex)) ;
+ DEBUG7 (("\n====================COL: " ID, dumpindex)) ;
}
if (dumpindex == EMPTY)
tp = (Tuple *) p ;
if (!tpi)
{
- DEBUG7 ((" Nonpivotal, No tuple list tuples "ID" tlen "ID"\n",
+ DEBUG7 ((" Nonpivotal, No tuple list tuples " ID " tlen " ID "\n",
tpi, len)) ;
return ;
}
ASSERT (p >= Numeric->Memory + Numeric->itail) ;
ASSERT (p < Numeric->Memory + Numeric->size) ;
- DEBUG7 ((" degree: "ID" len: "ID"\n", dumpdeg, len)) ;
+ DEBUG7 ((" degree: " ID " len: " ID "\n", dumpdeg, len)) ;
not_in_use = (p-1)->header.size - UNITS (Tuple, len) ;
- DEBUG7 ((" Tuple list: p+1: "ID" size: "ID" units, "ID" not in use\n",
+ DEBUG7 ((" Tuple list: p+1: " ID " size: " ID " units, " ID " not in use\n",
(Int) (p-Numeric->Memory), (p-1)->header.size, not_in_use)) ;
ASSERT (not_in_use >= 0) ;
tend = tp + len ;
for ( ; tp < tend ; tp++)
{
/* row/col of element e, offset is f: */
- /* DEBUG8 ((" (tp="ID")\n", tp)) ; */
+ /* DEBUG8 ((" (tp=" ID ")\n", tp)) ; */
e = tp->e ;
f = tp->f ;
- DEBUG8 ((" (e="ID", f="ID")\n", e, f)) ;
+ DEBUG8 ((" (e=" ID ", f=" ID ")\n", e, f)) ;
ASSERT (e > 0 && e <= Work->nel) ;
/* dump the pattern and values */
if (E [e])
C [ (dumpwhich == 0) ? (f+nrows*j) : (j+nrows*f) ] ;
if (index >= 0)
{
- DEBUG8 (("\t\t"ID":", index)) ;
+ DEBUG8 (("\t\t" ID ":", index)) ;
EDEBUG8 (value) ;
DEBUG8 (("\n")) ;
if (dumpwhich == 0)
{
if (deg > 0)
{
- DEBUG7 ((" Assembled, actual deg: "ID" : ", deg)) ;
+ DEBUG7 ((" Assembled, actual deg: " ID " : ", deg)) ;
for (j = 0 ; j < deg ; j++)
{
index = UMF_DBpacked [j] ;
- DEBUG8 ((ID" ", index)) ;
+ DEBUG8 ((ID " ", index)) ;
if (j % 20 == 19) DEBUG8 (("\n ")) ;
ASSERT (UMF_DBscatter [index] == UMF_DBflag) ;
}
/* Col_degree is not maintained when fixQ is true */
if (check_degree)
{
- DEBUG8 ((" approx_deg "ID" dumpdeg "ID"\n", approx_deg, dumpdeg)) ;
+ DEBUG8 ((" approx_deg " ID " dumpdeg " ID "\n", approx_deg, dumpdeg)) ;
ASSERT (approx_deg == dumpdeg) ;
}
n_row = Work->n_row ;
n_col = Work->n_col ;
- DEBUG6 (("n_row "ID" n_col "ID" nz "ID"\n", n_row, n_col, Work->nz)) ;
- DEBUG6 (("============================ ELEMENTS: "ID" \n", Work->nel)) ;
+ DEBUG6 (("n_row " ID " n_col " ID " nz " ID "\n", n_row, n_col, Work->nz)) ;
+ DEBUG6 (("============================ ELEMENTS: " ID " \n", Work->nel)) ;
intfrag = 0 ;
E = Work->E ;
if (!E)
actualsize = GET_ELEMENT_SIZE (ep->nrowsleft,ep->ncolsleft);
frag = fullsize - actualsize ;
intfrag += frag ;
- DEBUG7 (("dump el: "ID", full "ID" actual "ID" frag: "ID
- " intfrag: "ID"\n", e, fullsize, actualsize, frag,
+ DEBUG7 (("dump el: " ID ", full " ID " actual " ID " frag: " ID
+ " intfrag: " ID "\n", e, fullsize, actualsize, frag,
intfrag)) ;
}
}
}
- DEBUG6 (("CURRENT INTERNAL FRAG in elements: "ID" \n", intfrag)) ;
+ DEBUG6 (("CURRENT INTERNAL FRAG in elements: " ID " \n", intfrag)) ;
- DEBUG6 (("======================================== ROWS: "ID"\n", n_row)) ;
+ DEBUG6 (("======================================== ROWS: " ID "\n", n_row)) ;
UMF_debug -= 2 ;
for (row = 0 ; row < n_row ; row++)
{
UMF_dump_rowcol (0, Numeric, Work, row, check_degree) ;
}
UMF_debug += 2 ;
- DEBUG6 (("======================================== COLS: "ID"\n", n_col)) ;
+ DEBUG6 (("======================================== COLS: " ID "\n", n_col)) ;
UMF_debug -= 2 ;
for (col = 0 ; col < n_col ; col++)
{
fnpiv = Work->fnpiv ;
E = Work->E ;
- DEBUG6 (("=== fnpiv= "ID"\n", fnpiv)) ;
- DEBUG6 (("fnrows_max fncols_max "ID" "ID"\n",fnrows_max, fncols_max)) ;
- DEBUG6 (("fnr_curr fnc_curr "ID" "ID"\n",fnr_curr, fnc_curr)) ;
- DEBUG6 (("fnrows fncols "ID" "ID"\n",fnrows, fncols)) ;
+ DEBUG6 (("=== fnpiv= " ID "\n", fnpiv)) ;
+ DEBUG6 (("fnrows_max fncols_max " ID " " ID "\n",fnrows_max, fncols_max)) ;
+ DEBUG6 (("fnr_curr fnc_curr " ID " " ID "\n",fnr_curr, fnc_curr)) ;
+ DEBUG6 (("fnrows fncols " ID " " ID "\n",fnrows, fncols)) ;
ASSERT ((fnr_curr % 2 == 1) || fnr_curr == 0) ;
DEBUG6 (("Pivot row pattern:\n")) ;
for (j = 0 ; j < fncols ; j++)
{
- DEBUG7 ((ID" "ID" "ID" %d\n", j, Fcols [j], Fcpos [Fcols [j]],
+ DEBUG7 ((ID " " ID " " ID " %d\n", j, Fcols [j], Fcpos [Fcols [j]],
j < fncols)) ;
if (check)
{
DEBUG6 (("Pivot col pattern:\n")) ;
for (i = 0 ; i < fnrows ; i++)
{
- DEBUG7 ((ID" "ID" "ID" %d\n", i, Frows [i], Frpos [Frows [i]],
+ DEBUG7 ((ID " " ID " " ID " %d\n", i, Frows [i], Frpos [Frows [i]],
i < fnrows)) ;
if (check)
{
}
n_row = Numeric->n_row ;
n_col = Numeric->n_col ;
- DEBUG6 (("n_row: "ID" n_col: "ID"\n", n_row, n_col)) ;
- DEBUG6 (("nLentries: "ID" nUentries: "ID"\n",
+ DEBUG6 (("n_row: " ID " n_col: " ID "\n", n_row, n_col)) ;
+ DEBUG6 (("nLentries: " ID " nUentries: " ID "\n",
Numeric->nLentries, Numeric->nUentries)) ;
if (Numeric->Cperm)
{
if (Cperm [i] != EMPTY)
{
- DEBUG7 ((ID": "ID"\n", i, Cperm [i])) ;
+ DEBUG7 ((ID ": " ID "\n", i, Cperm [i])) ;
}
}
}
{
if (Rperm [i] != EMPTY)
{
- DEBUG7 ((ID": "ID"\n", i, Rperm [i])) ;
+ DEBUG7 ((ID ": " ID "\n", i, Rperm [i])) ;
}
}
}
return ;
}
- DEBUG6 (("S: "ID"\n", (Int) Numeric)) ;
- DEBUG6 (("S->ihead : "ID"\n", Numeric->ihead)) ;
- DEBUG6 (("S->itail : "ID"\n", Numeric->itail)) ;
- DEBUG6 (("S->size : "ID"\n", Numeric->size)) ;
- DEBUG6 (("S->ngarbage : "ID"\n", Numeric->ngarbage)) ;
- DEBUG6 (("S->nrealloc : "ID"\n", Numeric->nrealloc)) ;
- DEBUG6 ((" in use at head : "ID"\n", Numeric->ihead)) ;
- DEBUG6 ((" free space : "ID"\n",
+ DEBUG6 (("S: " ID "\n", (Int) Numeric)) ;
+ DEBUG6 (("S->ihead : " ID "\n", Numeric->ihead)) ;
+ DEBUG6 (("S->itail : " ID "\n", Numeric->itail)) ;
+ DEBUG6 (("S->size : " ID "\n", Numeric->size)) ;
+ DEBUG6 (("S->ngarbage : " ID "\n", Numeric->ngarbage)) ;
+ DEBUG6 (("S->nrealloc : " ID "\n", Numeric->nrealloc)) ;
+ DEBUG6 ((" in use at head : " ID "\n", Numeric->ihead)) ;
+ DEBUG6 ((" free space : " ID "\n",
Numeric->itail - Numeric->ihead)) ;
- DEBUG6 ((" blocks in use at tail : "ID"\n",
+ DEBUG6 ((" blocks in use at tail : " ID "\n",
Numeric->size - Numeric->itail)) ;
- DEBUG6 ((" total in use : "ID"\n",
+ DEBUG6 ((" total in use : " ID "\n",
Numeric->size - (Numeric->itail - Numeric->ihead))) ;
prevsize = 0 ;
while (p < Numeric->Memory + Numeric->size)
{
- DEBUG8 (("p: "ID" p+1: "ID" prevsize: "ID" size: "ID,
+ DEBUG8 (("p: " ID " p+1: " ID " prevsize: " ID " size: " ID,
(Int) (p-Numeric->Memory), (Int) (p+1-Numeric->Memory),
p->header.prevsize, p->header.size)) ;
if (p->header.size < 0)
DEBUG6 (("No memory space S allocated\n")) ;
return ;
}
- DEBUG6 (("S: "ID"\n", (Int) Numeric)) ;
- DEBUG6 (("S->ihead : "ID"\n", Numeric->ihead)) ;
- DEBUG6 (("S->itail : "ID"\n", Numeric->itail)) ;
- DEBUG6 (("S->size : "ID"\n", Numeric->size)) ;
- DEBUG6 (("S->ngarbage : "ID"\n", Numeric->ngarbage)) ;
- DEBUG6 (("S->nrealloc : "ID"\n", Numeric->nrealloc)) ;
- DEBUG6 ((" in use at head : "ID"\n", Numeric->ihead)) ;
- DEBUG6 ((" free space : "ID"\n",
+ DEBUG6 (("S: " ID "\n", (Int) Numeric)) ;
+ DEBUG6 (("S->ihead : " ID "\n", Numeric->ihead)) ;
+ DEBUG6 (("S->itail : " ID "\n", Numeric->itail)) ;
+ DEBUG6 (("S->size : " ID "\n", Numeric->size)) ;
+ DEBUG6 (("S->ngarbage : " ID "\n", Numeric->ngarbage)) ;
+ DEBUG6 (("S->nrealloc : " ID "\n", Numeric->nrealloc)) ;
+ DEBUG6 ((" in use at head : " ID "\n", Numeric->ihead)) ;
+ DEBUG6 ((" free space : " ID "\n",
Numeric->itail - Numeric->ihead)) ;
- DEBUG6 ((" blocks in use at tail : "ID"\n",
+ DEBUG6 ((" blocks in use at tail : " ID "\n",
Numeric->size - Numeric->itail)) ;
- DEBUG6 ((" total in use : "ID"\n",
+ DEBUG6 ((" total in use : " ID "\n",
Numeric->size - (Numeric->itail - Numeric->ihead))) ;
ASSERT (0 <= Numeric->ihead) ;
while (p < Numeric->Memory + Numeric->size)
{
DEBUG9 (("====================\n")) ;
- DEBUG7 (("p: "ID" p+1: "ID" prevsize: "ID" size: "ID"\n",
+ DEBUG7 (("p: " ID " p+1: " ID " prevsize: " ID " size: " ID "\n",
(Int) (p-Numeric->Memory), (Int) (p+1-Numeric->Memory),
p->header.prevsize, p->header.size)) ;
ASSERT (p->header.size > 0) ;
/* this is a packed element */
GET_ELEMENT (ep, p3, Cols, Rows, ncols, nrows, C) ;
- DEBUG9 (("ep "ID"\n nrows "ID" ncols "ID"\n",
+ DEBUG9 (("ep " ID "\n nrows " ID " ncols " ID "\n",
(Int) ((p+1)-Numeric->Memory), ep->nrows, ep->ncols)) ;
DEBUG9 (("rows:")) ;
for (k = 0 ; k < ep->nrows; k++)
{
row = Rows [k] ;
- DEBUG9 ((" "ID, row)) ;
+ DEBUG9 ((" " ID, row)) ;
ASSERT (row >= 0 && row <= Work->n_row) ;
if ((k % 10) == 9) DEBUG9 (("\n")) ;
}
for (k = 0 ; k < ep->ncols; k++)
{
col = Cols [k] ;
- DEBUG9 ((" "ID, col)) ;
+ DEBUG9 ((" " ID, col)) ;
ASSERT (col >= 0 && col <= Work->n_col) ;
if ((k % 10) == 9) DEBUG9 (("\n")) ;
}
UMF_dump_dense (C, ep->nrows, ep->nrows, ep->ncols) ;
}
esize = GET_ELEMENT_SIZE (ep->nrows, ep->ncols) ;
- DEBUG9 (("esize: "ID"\n", esize)) ;
+ DEBUG9 (("esize: " ID "\n", esize)) ;
ASSERT (esize <= p->header.size) ;
}
ASSERT (n_col >= 0) ;
nz = Ap [n_col] ;
- DEBUG2 (("UMF_dump_col: nz "ID"\n", nz)) ;
- DEBUG2 (("n_row "ID" \n", n_row)) ;
- DEBUG2 (("n_col "ID" \n", n_col)) ;
+ DEBUG2 (("UMF_dump_col: nz " ID "\n", nz)) ;
+ DEBUG2 (("n_row " ID " \n", n_row)) ;
+ DEBUG2 (("n_col " ID " \n", n_col)) ;
- DEBUG6 ((" n_row = "ID", n_col ="ID" nz = "ID" Ap [0] "ID", Ap [n] "ID"\n",
+ DEBUG6 ((" n_row = " ID ", n_col =" ID " nz = " ID " Ap [0] " ID ", Ap [n] " ID "\n",
n_row, n_col, nz, Ap [0], Ap [n_col])) ;
ASSERT (Ap [0] == 0) ;
ASSERT (Ap [n_col] == nz) ;
{
p1 = Ap [col] ;
p2 = Ap [col+1] ;
- DEBUG6 (("col: "ID", length "ID"\n", col, p2 - p1)) ;
+ DEBUG6 (("col: " ID ", length " ID "\n", col, p2 - p1)) ;
ASSERT (p2 >= p1) ;
for (p = p1 ; p < p2 ; p++)
{
row = Ai [p] ;
ASSERT (row >= 0 && row < n_row) ;
- DEBUG6 (("\t"ID" ", row)) ;
+ DEBUG6 (("\t" ID " ", row)) ;
if (Ax != (double *) NULL)
{
#ifdef COMPLEX
(Front_parent [i] > i && Front_parent [i] < nfr)) ;
len++ ;
- DEBUG3 (("Chain:\n "ID" ["ID","ID"]("ID"-by-"ID")\n", i,
+ DEBUG3 (("Chain:\n " ID " [" ID "," ID "](" ID "-by-" ID ")\n", i,
Front_npivcol [i],
MIN (Front_npivcol [i], Front_nrows [i]),
Front_nrows [i],
if (Front_parent [i] == i+1)
{
len++ ;
- DEBUG3 (("\t"ID" ["ID","ID"]("ID"-by-"ID")\n", i+1,
+ DEBUG3 (("\t" ID " [" ID "," ID "](" ID "-by-" ID ")\n", i+1,
Front_npivcol [i+1],
MIN (Front_npivcol [i+1], Front_nrows [i+1]),
Front_nrows [i+1],
}
else
{
- DEBUG2 (("Length of chain: "ID"\n", len)) ;
+ DEBUG2 (("Length of chain: " ID "\n", len)) ;
return ;
}
}
}
if (UMF_gprob > 1.0) UMF_gprob = 1.0 ;
- DEBUG1 (("factor: UMF_gprob: %e UMF_debug "ID"\n", UMF_gprob, UMF_debug)) ;
+ DEBUG1 (("factor: UMF_gprob: %e UMF_debug " ID "\n", UMF_gprob, UMF_debug)) ;
DEBUG2 (("sizeof: (bytes / int / Units) \n")) ;
DEBUG2 (("sizeof (Int) %u %u %u\n",
fleftmost, nfr, n_row, *Row_degree, i, frontid, row ;
nfr = Symbolic->nfr ;
- DEBUG3 (("\n================== Row merge sets: nfr "ID"\n", nfr)) ;
+ DEBUG3 (("\n================== Row merge sets: nfr " ID "\n", nfr)) ;
Front_leftmostdesc = Symbolic->Front_leftmostdesc ;
Front_1strow = Symbolic->Front_1strow ;
Front_new1strow = Work->Front_new1strow ;
{
DEBUG3 (("----------------------\n")) ;
if (i == nfr) DEBUG3 (("Dummy: ")) ;
- DEBUG3 (("Front "ID" 1strow "ID" new1strow "ID" leftmostdesc "ID,
+ DEBUG3 (("Front " ID " 1strow " ID " new1strow " ID " leftmostdesc " ID,
i, Front_1strow [i], Front_new1strow [i], Front_leftmostdesc [i])) ;
- DEBUG3 ((" parent "ID" pivcol "ID"\n", Symbolic->Front_parent [i],
+ DEBUG3 ((" parent " ID " pivcol " ID "\n", Symbolic->Front_parent [i],
Symbolic->Front_npivcol [i])) ;
if (i == nfr)
row1 = Front_new1strow [fleftmost] ;
row2 = Front_1strow [i+1] - 1 ;
}
- DEBUG3 (("Leftmost: "ID" Rows ["ID" to "ID"], search ["ID" to "ID"]\n",
+ DEBUG3 (("Leftmost: " ID " Rows [" ID " to " ID "], search [" ID " to " ID "]\n",
fleftmost, Front_1strow [i], row2, row1, row2)) ;
for (row = row1 ; row <= row2 ; row++)
{
ASSERT (row >= 0 && row < n_row) ;
- DEBUG3 ((" Row "ID" live: %d\n", row, NON_PIVOTAL_ROW (row))) ;
+ DEBUG3 ((" Row " ID " live: %d\n", row, NON_PIVOTAL_ROW (row))) ;
}
}
}
Int row, col ;
if (Diagonal_map != (Int *) NULL)
{
- DEBUG2 (("\nDump the Diagonal_map: n1 "ID" nn "ID" nempty "ID"\n",
+ DEBUG2 (("\nDump the Diagonal_map: n1 " ID " nn " ID " nempty " ID "\n",
n1, nn, nempty)) ;
for (col = n1 ; col < nn - nempty ; col++)
{
row = Diagonal_map [col] ;
- DEBUG2 ((" Diagonal_map [col = "ID"] gives "ID": ",
+ DEBUG2 ((" Diagonal_map [col = " ID "] gives " ID ": ",
col, row)) ;
row = UNFLIP (row) ;
- DEBUG2 ((" row "ID"\n", row)) ;
+ DEBUG2 ((" row " ID "\n", row)) ;
ASSERT (Diagonal_imap [row] == col) ;
}
}
#ifndef NDEBUG
DEBUG2 (("EXTEND FRONT\n")) ;
- DEBUG2 (("Work->fnpiv "ID"\n", fnpiv)) ;
+ DEBUG2 (("Work->fnpiv " ID "\n", fnpiv)) ;
ASSERT (Work->Flblock == Work->Flublock + Work->nb*Work->nb) ;
ASSERT (Work->Fublock == Work->Flblock + Work->fnr_curr*Work->nb) ;
ASSERT (Work->Fcblock == Work->Fublock + Work->nb*Work->fnc_curr) ;
fncols_extended = fncols ;
#ifndef NDEBUG
- DEBUG2 (("Pivot col, before extension: "ID"\n", fnrows)) ;
+ DEBUG2 (("Pivot col, before extension: " ID "\n", fnrows)) ;
for (i = 0 ; i < fnrows ; i++)
{
- DEBUG2 ((" "ID": row "ID"\n", i, Frows [i])) ;
+ DEBUG2 ((" " ID ": row " ID "\n", i, Frows [i])) ;
ASSERT (Frpos [Frows [i]] == i) ;
}
- DEBUG2 (("Extending pivot column: pivcol_in_front: "ID"\n",
+ DEBUG2 (("Extending pivot column: pivcol_in_front: " ID "\n",
Work->pivcol_in_front)) ;
#endif
Fl [i] = Wy [i] ;
#ifndef NDEBUG
row = Frows [i] ;
- DEBUG2 ((" "ID": row "ID" ", i, row)) ;
+ DEBUG2 ((" " ID ": row " ID " ", i, row)) ;
EDEBUG2 (Fl [i]) ;
if (row == Work->pivrow) DEBUG2 ((" <- pivrow")) ;
DEBUG2 (("\n")) ;
{
row = Wm [i] ;
#ifndef NDEBUG
- DEBUG2 ((" "ID": row "ID" (ext) ", fnrows_extended, row)) ;
+ DEBUG2 ((" " ID ": row " ID " (ext) ", fnrows_extended, row)) ;
EDEBUG2 (Wx [i]) ;
if (row == Work->pivrow) DEBUG2 ((" <- pivrow")) ;
DEBUG2 (("\n")) ;
/* ---------------------------------------------------------------------- */
#ifndef NDEBUG
- DEBUG6 (("Pivot row, before extension: "ID"\n", fncols)) ;
+ DEBUG6 (("Pivot row, before extension: " ID "\n", fncols)) ;
for (j = 0 ; j < fncols ; j++)
{
- DEBUG7 ((" "ID": col "ID"\n", j, Fcols [j])) ;
+ DEBUG7 ((" " ID ": col " ID "\n", j, Fcols [j])) ;
ASSERT (Fcpos [Fcols [j]] == j * fnr_curr) ;
}
DEBUG6 (("Extending pivot row:\n")) ;
{
#ifndef NDEBUG
col = Fcols [j] ;
- DEBUG2 ((" "ID": col "ID" (ext)\n", j, col)) ;
+ DEBUG2 ((" " ID ": col " ID " (ext)\n", j, col)) ;
ASSERT (col != Work->pivcol) ;
ASSERT (col >= 0 && col < Work->n_col) ;
ASSERT (Fcpos [col] < 0) ;
for (j = fncols ; j < rrdeg ; j++)
{
col = Wrow [j] ;
- DEBUG2 ((" "ID": col "ID" (ext)\n", j, col)) ;
+ DEBUG2 ((" " ID ": col " ID " (ext)\n", j, col)) ;
ASSERT (Fcpos [col] < 0) ;
/* Fcols [j] = col ; not needed */
Fcpos [col] = j * fnr_curr ;
for (j = fncols ; j < rrdeg ; j++)
{
col = Wrow [j] ;
- DEBUG2 ((" "ID": col "ID" (ext)\n", j, col)) ;
+ DEBUG2 ((" " ID ": col " ID " (ext)\n", j, col)) ;
ASSERT (Fcpos [col] < 0) ;
Fcols [j] = col ;
Fcpos [col] = j * fnr_curr ;
ASSERT (col >= 0 && col < Work->n_col) ;
if (Fcpos [col] < 0)
{
- DEBUG2 ((" col:: "ID" (ext)\n", col)) ;
+ DEBUG2 ((" col:: " ID " (ext)\n", col)) ;
Fcols [fncols_extended] = col ;
Fcpos [col] = fncols_extended * fnr_curr ;
fncols_extended++ ;
ASSERT (fncols_extended <= fnc_curr) ;
ASSERT (fnrows_extended <= fnr_curr) ;
- DEBUG6 (("Pivot col, after ext: "ID" "ID"\n", fnrows,fnrows_extended)) ;
+ DEBUG6 (("Pivot col, after ext: " ID " " ID "\n", fnrows,fnrows_extended)) ;
for (i = 0 ; i < fnrows_extended ; i++)
{
row = Frows [i] ;
- DEBUG7 ((" "ID": row "ID" pos "ID" old: %d", i, row, Frpos [row],
+ DEBUG7 ((" " ID ": row " ID " pos " ID " old: %d", i, row, Frpos [row],
i < fnrows)) ;
if (row == Work->pivrow ) DEBUG7 ((" <-- pivrow")) ;
DEBUG7 (("\n")) ;
ASSERT (Frpos [Frows [i]] == i) ;
}
- DEBUG6 (("Pivot row position: "ID"\n", Frpos [Work->pivrow])) ;
+ DEBUG6 (("Pivot row position: " ID "\n", Frpos [Work->pivrow])) ;
ASSERT (Frpos [Work->pivrow] >= 0) ;
ASSERT (Frpos [Work->pivrow] < fnrows_extended) ;
- DEBUG6 (("Pivot row, after ext: "ID" "ID"\n", fncols,fncols_extended)) ;
+ DEBUG6 (("Pivot row, after ext: " ID " " ID "\n", fncols,fncols_extended)) ;
for (j = 0 ; j < fncols_extended ; j++)
{
col = Fcols [j] ;
- DEBUG7 ((" "ID": col "ID" pos "ID" old: %d", j, col, Fcpos [col],
+ DEBUG7 ((" " ID ": col " ID " pos " ID " old: %d", j, col, Fcpos [col],
j < fncols)) ;
if (col == Work->pivcol ) DEBUG7 ((" <-- pivcol")) ;
DEBUG7 (("\n")) ;
ASSERT (Fcpos [Fcols [j]] == j * fnr_curr) ;
}
- DEBUG6 (("Pivot col position: "ID"\n", Fcpos [Work->pivcol])) ;
+ DEBUG6 (("Pivot col position: " ID "\n", Fcpos [Work->pivcol])) ;
ASSERT (Fcpos [Work->pivcol] >= 0) ;
ASSERT (Fcpos [Work->pivcol] < fncols_extended * fnr_curr) ;
void *p
)
{
- DEBUG0 (("UMF_free: "ID"\n", (Int) p)) ;
+ DEBUG0 (("UMF_free: " ID "\n", (Int) p)) ;
if (p)
{
/* One more object has been free'd. Keep track of the count. */
/* (purely for sanity checks). */
UMF_malloc_count-- ;
- DEBUG0 ((" new malloc count: "ID"\n", UMF_malloc_count)) ;
+ DEBUG0 ((" new malloc count: " ID "\n", UMF_malloc_count)) ;
#endif
}
/* :: frsize int overflow :: */
frsize = Int_MAX ;
}
- DEBUG1 ((""ID" : npiv "ID" size "ID" parent "ID" ",
+ DEBUG1 (("" ID " : npiv " ID " size " ID " parent " ID " ",
j, Npiv [j], frsize, parent)) ;
Fsize [j] = MAX (Fsize [j], frsize) ;
- DEBUG1 (("Fsize [j = "ID"] = "ID"\n", j, Fsize [j])) ;
+ DEBUG1 (("Fsize [j = " ID "] = " ID "\n", j, Fsize [j])) ;
if (parent != EMPTY)
{
/* find the maximum frontsize of self and children */
ASSERT (Npiv [parent] > 0) ;
ASSERT (parent > j) ;
Fsize [parent] = MAX (Fsize [parent], Fsize [j]) ;
- DEBUG1 (("Fsize [parent = "ID"] = "ID"\n",
+ DEBUG1 (("Fsize [parent = " ID "] = " ID "\n",
parent, Fsize [parent]));
}
}
{
if (NON_PIVOTAL_ROW (row) && Row_tuples [row])
{
- DEBUG2 (("row "ID" tuples "ID"\n", row, Row_tuples [row])) ;
+ DEBUG2 (("row " ID " tuples " ID "\n", row, Row_tuples [row])) ;
p = Numeric->Memory + Row_tuples [row] - 1 ;
- DEBUG2 (("Freeing tuple list row "ID", p-S "ID", size "ID"\n",
+ DEBUG2 (("Freeing tuple list row " ID ", p-S " ID ", size " ID "\n",
row, (Int) (p-Numeric->Memory), p->header.size)) ;
ASSERT (p->header.size > 0) ;
ASSERT (p >= Numeric->Memory + Numeric->itail) ;
{
if (NON_PIVOTAL_COL (col) && Col_tuples [col])
{
- DEBUG2 (("col "ID" tuples "ID"\n", col, Col_tuples [col])) ;
+ DEBUG2 (("col " ID " tuples " ID "\n", col, Col_tuples [col])) ;
p = Numeric->Memory + Col_tuples [col] - 1 ;
- DEBUG2 (("Freeing tuple list col "ID", p-S "ID", size "ID"\n",
+ DEBUG2 (("Freeing tuple list col " ID ", p-S " ID ", size " ID "\n",
col, (Int) (p-Numeric->Memory), p->header.size)) ;
ASSERT (p->header.size > 0) ;
ASSERT (p >= Numeric->Memory + Numeric->itail) ;
#ifndef NDEBUG
nmark = 0 ;
UMF_dump_current_front (Numeric, Work, FALSE) ;
- DEBUGm1 (("E [0] "ID" \n", E [0])) ;
+ DEBUGm1 (("E [0] " ID " \n", E [0])) ;
ASSERT (IMPLIES (E [0],
Work->Flublock == (Entry *) (Numeric->Memory + E [0]))) ;
ASSERT (IMPLIES (Work->Flublock,
#ifndef NDEBUG
nmark++ ;
#endif
- DEBUG7 ((ID":: Mark e "ID" at psrc-S "ID", new e "ID"\n",
+ DEBUG7 ((ID ":: Mark e " ID " at psrc-S " ID ", new e " ID "\n",
nmark, e, (Int) (psrc-Numeric->Memory), e2)) ;
E [e] = 0 ;
if (e == Work->prior_element)
/* a free block will have a negative size, so skip it */
/* otherwise, if size >= 0, it holds the element name, not the size */
- DEBUG8 (("psrc-S: "ID" prevsize: "ID" size: "ID,
+ DEBUG8 (("psrc-S: " ID " prevsize: " ID " size: " ID,
(Int) (psrc-Numeric->Memory), prevsize, size)) ;
if (e == 0)
pnext = pdest ;
#ifndef NDEBUG
- DEBUGm2 (("move front: dr "ID" dc "ID" r "ID" drnew "ID" c "ID
- " dcnew " ID" k "ID"\n", dr, dc, r, drnew, c, dcnew, k)) ;
+ DEBUGm2 (("move front: dr " ID " dc " ID " r " ID " drnew " ID " c " ID
+ " dcnew " ID " k " ID "\n", dr, dc, r, drnew, c, dcnew, k)) ;
DEBUG7 (("\n")) ;
- DEBUG7 ((ID":: Move current frontal matrix from: psrc-S: "ID" \n",
+ DEBUG7 ((ID ":: Move current frontal matrix from: psrc-S: " ID " \n",
nmark, (Int) (psrc-Numeric->Memory))) ;
nmark-- ;
ASSERT (E [e] == 0) ;
{
if (Fcpos [j] != EMPTY) cnt++ ;
}
- DEBUGm2 (("Recompute Fcpos cnt "ID" c "ID"\n", cnt, c)) ;
+ DEBUGm2 (("Recompute Fcpos cnt " ID " c " ID "\n", cnt, c)) ;
ASSERT (cnt == c) ;
}
#endif
}
#ifndef NDEBUG
- DEBUGm2 (("Compacted front, drnew "ID" dcnew "ID"\n", drnew, dcnew)) ;
+ DEBUGm2 (("Compacted front, drnew " ID " dcnew " ID "\n", drnew, dcnew)) ;
DEBUG7 (("C block: ")) ;
UMF_dump_dense (F1 + nb*nb + drnew*nb + nb*dcnew, drnew, r, c) ;
DEBUG7 (("L block: ")) ;
#ifndef NDEBUG
DEBUG7 (("\n")) ;
- DEBUG7 ((ID":: Move element "ID": from: "ID" \n",
+ DEBUG7 ((ID ":: Move element " ID ": from: " ID " \n",
nmark, e, (Int) (psrc-Numeric->Memory))) ;
nmark-- ;
ASSERT (e <= nel) ;
rdeg = epsrc->rdeg ;
#ifndef NDEBUG
- DEBUG7 ((" nrows "ID" nrowsleft "ID"\n", nrows, nrowsleft)) ;
- DEBUG7 ((" ncols "ID" ncolsleft "ID"\n", ncols, ncolsleft)) ;
+ DEBUG7 ((" nrows " ID " nrowsleft " ID "\n", nrows, nrowsleft)) ;
+ DEBUG7 ((" ncols " ID " ncolsleft " ID "\n", ncols, ncolsleft)) ;
DEBUG8 ((" Rows:")) ;
- for (i = 0 ; i < nrows ; i++) DEBUG8 ((" "ID, Rows [i])) ;
+ for (i = 0 ; i < nrows ; i++) DEBUG8 ((" " ID, Rows [i])) ;
DEBUG8 (("\n Cols:")) ;
- for (j = 0 ; j < ncols ; j++) DEBUG8 ((" "ID, Cols [j])) ;
+ for (j = 0 ; j < ncols ; j++) DEBUG8 ((" " ID, Cols [j])) ;
DEBUG8 (("\n")) ;
#endif
+ UNITS (Int, nrowsleft + ncolsleft)
+ UNITS (Entry, csize) ;
- DEBUG7 (("Old size "ID" New size "ID"\n", size, size2)) ;
+ DEBUG7 (("Old size " ID " New size " ID "\n", size, size2)) ;
pnext = pdest ;
pnext->header.prevsize = size2 ;
DEBUG8 ((" free\n")) ;
}
#endif
- DEBUG7 (("psrc "ID" tail "ID"\n",
+ DEBUG7 (("psrc " ID " tail " ID "\n",
(Int) (psrc-Numeric->Memory), Numeric->itail)) ;
}
/* determine the desired new size of memory */
/* ---------------------------------------------------------------------- */
- DEBUG0 (("UMF_get_memory: needunits: "ID"\n", needunits)) ;
+ DEBUG0 (("UMF_get_memory: needunits: " ID "\n", needunits)) ;
minsize = Numeric->size + needunits ;
nsize += (double) Numeric->size ;
newsize = MAX (newsize, Numeric->size) ;
DEBUG0 ((
- "REALLOC MEMORY: needunits "ID" old size: "ID" new size: "ID" Units \n",
+ "REALLOC MEMORY: needunits " ID " old size: " ID " new size: " ID " Units \n",
needunits, Numeric->size, newsize)) ;
/* Forget where the biggest free block is (we no longer need it) */
/* since garbage collection will occur shortly. */
Numeric->ibig = EMPTY ;
- DEBUG0 (("Before realloc E [0] "ID"\n", Work->E [0])) ;
+ DEBUG0 (("Before realloc E [0] " ID "\n", Work->E [0])) ;
/* ---------------------------------------------------------------------- */
/* reallocate the memory, if possible, and make it bigger */
Work->Flblock = Work->Flublock + nb * nb ;
Work->Fublock = Work->Flblock + dr * nb ;
Work->Fcblock = Work->Fublock + nb * dc ;
- DEBUG0 (("after realloc E [0] "ID"\n", Work->E [0])) ;
+ DEBUG0 (("after realloc E [0] " ID "\n", Work->E [0])) ;
}
ASSERT (IMPLIES (!(Work->E [0]), Work->Flublock == (Entry *) NULL)) ;
#ifndef NDEBUG
if (do_what != -1) UMF_debug++ ;
- DEBUG0 (("\n\n====================GROW FRONT: do_what: "ID"\n", do_what)) ;
+ DEBUG0 (("\n\n====================GROW FRONT: do_what: " ID "\n", do_what)) ;
if (do_what != -1) UMF_debug-- ;
ASSERT (Work->do_grow) ;
ASSERT (Work->fnpiv == 0) ;
fnrows_max = Work->fnrows_max + nb ;
fncols_max = Work->fncols_max + nb ;
ASSERT (fnrows_max >= 0 && (fnrows_max % 2) == 1) ;
- DEBUG0 (("Max size: "ID"-by-"ID" (incl. "ID" pivot block\n",
+ DEBUG0 (("Max size: " ID "-by-" ID " (incl. " ID " pivot block\n",
fnrows_max, fncols_max, nb)) ;
/* current dimensions of frontal matrix: fnr-by-fnc */
- DEBUG0 (("Current : "ID"-by-"ID" (excl "ID" pivot blocks)\n",
+ DEBUG0 (("Current : " ID "-by-" ID " (excl " ID " pivot blocks)\n",
Work->fnr_curr, Work->fnc_curr, nb)) ;
ASSERT (Work->fnr_curr >= 0) ;
ASSERT ((Work->fnr_curr % 2 == 1) || Work->fnr_curr == 0) ;
ASSERT (fnr_min >= 0) ;
ASSERT (fnr_min % 2 == 1) ;
- DEBUG0 (("Min : "ID"-by-"ID"\n", fnr_min, fnc_min)) ;
+ DEBUG0 (("Min : " ID "-by-" ID "\n", fnr_min, fnc_min)) ;
/* grow the front to fnr2-by-fnc2, but no bigger than the maximum,
* and no smaller than the minumum. */
- DEBUG0 (("Desired : ("ID"+"ID")-by-("ID"+"ID")\n", fnr2, nb, fnc2, nb)) ;
+ DEBUG0 (("Desired : (" ID "+" ID ")-by-(" ID "+" ID ")\n", fnr2, nb, fnc2, nb)) ;
fnr2 += nb ;
fnc2 += nb ;
ASSERT (fnr2 >= 0) ;
fnc2 = MAX (fnc2, fnc_min) ;
fnr2 = MIN (fnr2, fnrows_max) ;
fnc2 = MIN (fnc2, fncols_max) ;
- DEBUG0 (("Try : "ID"-by-"ID"\n", fnr2, fnc2)) ;
+ DEBUG0 (("Try : " ID "-by-" ID "\n", fnr2, fnc2)) ;
ASSERT (fnr2 >= 0) ;
ASSERT (fnr2 % 2 == 1) ;
}
#endif
- DEBUG0 (("Attempt size: "ID"-by-"ID"\n", fnr2, fnc2)) ;
+ DEBUG0 (("Attempt size: " ID "-by-" ID "\n", fnr2, fnc2)) ;
eloc = UMF_mem_alloc_tail_block (Numeric, UNITS (Entry, newsize)) ;
if (!eloc)
/* :: out of memory in umf_grow_front :: */
return (FALSE) ; /* out of memory */
}
- DEBUG0 (("Attempt size: "ID"-by-"ID" again\n", fnr2, fnc2)) ;
+ DEBUG0 (("Attempt size: " ID "-by-" ID " again\n", fnr2, fnc2)) ;
eloc = UMF_mem_alloc_tail_block (Numeric, UNITS (Entry, newsize)) ;
}
ASSERT (fnr2 >= 0) ;
if (fnr2 % 2 == 0) fnr2++ ;
newsize = fnr2 * fnc2 ;
- DEBUGm3 (("Attempt smaller size: "ID"-by-"ID" minsize "ID"-by-"ID"\n",
+ DEBUGm3 (("Attempt smaller size: " ID "-by-" ID " minsize " ID "-by-" ID "\n",
fnr2, fnc2, fnr_min, fnc_min)) ;
eloc = UMF_mem_alloc_tail_block (Numeric, UNITS (Entry, newsize)) ;
}
fnr2 = fnr_min ;
fnc2 = fnc_min ;
newsize = minsize ;
- DEBUG0 (("Attempt minsize: "ID"-by-"ID"\n", fnr2, fnc2)) ;
+ DEBUG0 (("Attempt minsize: " ID "-by-" ID "\n", fnr2, fnc2)) ;
eloc = UMF_mem_alloc_tail_block (Numeric, UNITS (Entry, newsize)) ;
}
for (j = 0 ; j < fncols ; j++)
{
col = Fcols [j] ;
- DEBUG1 (("copy col "ID" \n",col)) ;
+ DEBUG1 (("copy col " ID " \n",col)) ;
ASSERT (col >= 0 && col < Work->n_col) ;
for (i = 0 ; i < fnrows ; i++)
{
}
Fcnew += fnr2 ;
Fcold += fnr_curr ;
- DEBUG1 (("new offset col "ID" "ID"\n",col, j * fnr2)) ;
+ DEBUG1 (("new offset col " ID " " ID "\n",col, j * fnr2)) ;
Fcpos [col] = j * fnr2 ;
}
}
for (j = 0 ; j < fncols ; j++)
{
col = Fcols [j] ;
- DEBUG1 (("new offset col "ID" "ID"\n",col, j * fnr2)) ;
+ DEBUG1 (("new offset col " ID " " ID "\n",col, j * fnr2)) ;
Fcpos [col] = j * fnr2 ;
}
}
ASSERT (Work->fnr_curr >= 0) ;
ASSERT (Work->fnr_curr % 2 == 1) ;
- DEBUG0 (("Newly grown front: "ID"+"ID" by "ID"+"ID"\n", Work->fnr_curr,
+ DEBUG0 (("Newly grown front: " ID "+" ID " by " ID "+" ID "\n", Work->fnr_curr,
nb, Work->fnc_curr, nb)) ;
return (TRUE) ;
}
#ifndef NDEBUG
DEBUG1 (("CURR after grow:\n")) ;
UMF_dump_current_front (Numeric, Work, FALSE) ;
- DEBUG1 (("fnrows new "ID" fncols new "ID"\n",
+ DEBUG1 (("fnrows new " ID " fncols new " ID "\n",
Work->fnrows_new, Work->fncols_new)) ;
#endif
ASSERT (Work->fnpiv == 0) ;
Work->fnrows = fnrows ;
#ifndef NDEBUG
- DEBUG3 (("New Pivot col "ID" now in front, length "ID"\n",
+ DEBUG3 (("New Pivot col " ID " now in front, length " ID "\n",
Work->pivcol, fnrows)) ;
for (i = 0 ; i < fnrows ; i++)
{
- DEBUG4 ((" "ID": row "ID"\n", i, Frows [i])) ;
+ DEBUG4 ((" " ID ": row " ID "\n", i, Frows [i])) ;
ASSERT (Frpos [Frows [i]] == i) ;
}
#endif
}
}
- DEBUGm1 (("rrdeg "ID" fncols "ID"\n", rrdeg, fncols)) ;
+ DEBUGm1 (("rrdeg " ID " fncols " ID "\n", rrdeg, fncols)) ;
fncols = rrdeg ;
Work->fncols = fncols ;
zero_init_front (fncols, fnrows, Fcblock, fnr_curr) ;
#ifndef NDEBUG
- DEBUG3 (("New Pivot row "ID" now in front, length "ID" fnr_curr "ID"\n",
+ DEBUG3 (("New Pivot row " ID " now in front, length " ID " fnr_curr " ID "\n",
Work->pivrow, fncols, fnr_curr)) ;
for (j = 0 ; j < fncols ; j++)
{
- DEBUG4 (("col "ID" position "ID"\n", j, Fcols [j])) ;
+ DEBUG4 (("col " ID " position " ID "\n", j, Fcols [j])) ;
ASSERT (Fcpos [Fcols [j]] == j * fnr_curr) ;
}
#endif
for (k = 0 ; k < r ; k++)
{
i = P [k] ;
- DEBUG5 (("k "ID" i "ID"\n", k, i)) ;
+ DEBUG5 (("k " ID " i " ID "\n", k, i)) ;
if (i < 0 || i >= n)
{
- DEBUG0 (("i out of range "ID" "ID"\n", i, n)) ;
+ DEBUG0 (("i out of range " ID " " ID "\n", i, n)) ;
return (FALSE) ;
}
if (W [i])
{
- DEBUG0 (("i duplicate "ID"\n", i)) ;
+ DEBUG0 (("i duplicate " ID "\n", i)) ;
return (FALSE) ;
}
W [i] = TRUE ;
Int i ;
f1 = Chain_start [chain] ;
f2 = Chain_start [chain+1] - 1 ;
- DEBUG1 (("\nCHain: "ID" start "ID" end "ID"\n", chain, f1, f2)) ;
+ DEBUG1 (("\nCHain: " ID " start " ID " end " ID "\n", chain, f1, f2)) ;
for (i = f1 ; i <= f2 ; i++)
{
- DEBUG1 (("Front "ID", npivcol "ID"\n", i, Front_npivcol [i])) ;
+ DEBUG1 (("Front " ID ", npivcol " ID "\n", i, Front_npivcol [i])) ;
}
}
#endif
Work->hi = Work->nextcand + Work->ncand - 1 ;
jmax = MIN (MAX_CANDIDATES, Work->ncand) ;
DEBUGm1 ((">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Starting front "
- ID", npivcol: "ID"\n", Work->frontid, Work->ncand)) ;
+ ID ", npivcol: " ID "\n", Work->frontid, Work->ncand)) ;
if (fixQ)
{
/* do not modify the column order */
DEBUGm1 (("Initial candidates: ")) ;
for (j = 0 ; j < jmax ; j++)
{
- DEBUGm1 ((" "ID, Work->nextcand)) ;
+ DEBUGm1 ((" " ID, Work->nextcand)) ;
ASSERT (Work->nextcand <= Work->hi) ;
Work->Candidates [j] = Work->nextcand++ ;
}
len = *p_len ;
Bi = (Int *) (Memory + p) ; p += UNITS (Int, len) ;
Bx = (Entry *) (Memory + p) ; p += UNITS (Entry, len) ;
- DEBUGm4 ((" p "ID" len "ID" pnew "ID"\n", p, len, pnew)) ;
+ DEBUGm4 ((" p " ID " len " ID " pnew " ID "\n", p, len, pnew)) ;
/* the vector resides in Bi [0..len-1] and Bx [0..len-1] */
{
i = Bi [p] ;
x = Bx [p] ;
- DEBUGm4 ((" old vector: i "ID" value: ", i)) ;
+ DEBUGm4 ((" old vector: i " ID " value: ", i)) ;
EDEBUGk (-4, x) ;
DEBUGm4 (("\n")) ;
ASSERT (i >= 0) ;
#ifndef NDEBUG
for (p = 0 ; p < len_new ; p++)
{
- DEBUGm4 ((" new vector: i "ID" value: ", Bi [p])) ;
+ DEBUGm4 ((" new vector: i " ID " value: ", Bi [p])) ;
EDEBUGk (-4, Bx [p]) ;
DEBUGm4 (("\n")) ;
ASSERT (Bi [p] >= 0) ;
*p_len = len_new ;
Bi2 = (Int *) (Memory + pnew) ; pnew += UNITS (Int, len_new) ;
Bx2 = (Entry *) (Memory + pnew) ; pnew += UNITS (Entry, len_new) ;
- DEBUGm4 ((" pnew "ID" len_new "ID"\n", pnew, len_new)) ;
+ DEBUGm4 ((" pnew " ID " len_new " ID "\n", pnew, len_new)) ;
/* shift the vector upwards, into its new space */
for (p = 0 ; p < len_new ; p++)
#ifndef NDEBUG
for (p = 0 ; p < len_new ; p++)
{
- DEBUGm4 ((" packed vec: i "ID" value: ", Bi2 [p])) ;
+ DEBUGm4 ((" packed vec: i " ID " value: ", Bi2 [p])) ;
EDEBUGk (-4, Bx2 [p]) ;
DEBUGm4 (("\n")) ;
ASSERT (Bi2 [p] >= 0) ;
Rdeg = Symbolic->Rdeg ;
n1 = Symbolic->n1 ;
dense_row_threshold = Symbolic->dense_row_threshold ;
- DEBUG0 (("Singletons: "ID"\n", n1)) ;
+ DEBUG0 (("Singletons: " ID "\n", n1)) ;
Work->nforced = 0 ;
Work->ndiscard = 0 ;
Work->noff_diagonal = 0 ;
/* ---------------------------------------------------------------------- */
UMF_mem_init_memoryspace (Numeric) ;
- DEBUG1 (("Kernel init head usage, before allocs: "ID"\n", Numeric->ihead)) ;
+ DEBUG1 (("Kernel init head usage, before allocs: " ID "\n", Numeric->ihead)) ;
/* ---------------------------------------------------------------------- */
/* initialize the Work and Numeric objects */
Rs [row] += value ;
}
}
- DEBUG4 (("i "ID" j "ID" value %g, Rs[i]: %g\n",
+ DEBUG4 (("i " ID " j " ID " value %g, Rs[i]: %g\n",
row, col, value, Rs[row])) ;
ilast = row ;
}
DEBUG2 (("sum %30.20e ", Rs [row])) ;
rsmin = MIN (rsmin, Rs [row]) ;
rsmax = MAX (rsmax, Rs [row]) ;
- DEBUG2 (("Rs["ID"] = %30.20e\n", row, Rs [row])) ;
+ DEBUG2 (("Rs[" ID "] = %30.20e\n", row, Rs [row])) ;
}
#ifndef NRECIPROCAL
/* multiply by the reciprocal if Rs is not too small */
lnz = Cdeg [k] - 1 ;
unz = Rdeg [k] - 1 ;
- DEBUG1 (("Singleton k "ID" pivrow "ID" pivcol "ID" cdeg "ID" rdeg "
- ID"\n", k, Rperm_init [k], Cperm_init [k], Cdeg [k], Rdeg [k])) ;
+ DEBUG1 (("Singleton k " ID " pivrow " ID " pivcol " ID " cdeg " ID " rdeg "
+ ID "\n", k, Rperm_init [k], Cperm_init [k], Cdeg [k], Rdeg [k])) ;
ASSERT (unz >= 0 && lnz >= 0 && (lnz == 0 || unz == 0)) ;
- DEBUG1 ((" lnz "ID" unz "ID"\n", lnz, unz)) ;
+ DEBUG1 ((" lnz " ID " unz " ID "\n", lnz, unz)) ;
size = UNITS (Int, lnz) + UNITS (Entry, lnz)
+ UNITS (Int, unz) + UNITS (Entry, unz) ;
p = UMF_mem_alloc_head_block (Numeric, size) ;
- DEBUG1 (("Kernel init head usage: "ID"\n", Numeric->ihead)) ;
+ DEBUG1 (("Kernel init head usage: " ID "\n", Numeric->ihead)) ;
if (!p)
{
/* :: pattern change (out of memory for singletons) :: */
return (FALSE) ; /* pattern has changed */
}
Cols [0] = k ;
- DEBUG0 (("Got column element e "ID" esize "ID"\n", e, esize)) ;
+ DEBUG0 (("Got column element e " ID " esize " ID "\n", e, esize)) ;
}
else
{
/* all rows in this column are dense, or empty */
E [e] = 0 ;
empty_elements = TRUE ;
- DEBUG0 (("column element e is empty "ID"\n", e)) ;
+ DEBUG0 (("column element e is empty " ID "\n", e)) ;
}
}
- DEBUG0 (("e "ID" n_col "ID" nempty_col "ID" n1 "ID"\n", e, n_col,
+ DEBUG0 (("e " ID " n_col " ID " nempty_col " ID " n1 " ID "\n", e, n_col,
nempty_col, n1)) ;
ASSERT (e == n_col - nempty_col - n1) ;
Rpi [k] = Cols ;
Rpx [k] = C ;
Wp [k] = rdeg ;
- DEBUG0 (("Got row element e "ID" rdeg "ID"\n", e, rdeg)) ;
+ DEBUG0 (("Got row element e " ID " rdeg " ID "\n", e, rdeg)) ;
}
}
}
else if (newrow < k)
{
/* this entry goes in a row of U */
- DEBUG1 (("Singleton row of U: k "ID" newrow "ID"\n",
+ DEBUG1 (("Singleton row of U: k " ID " newrow " ID "\n",
k, newrow)) ;
if (--(Wp [newrow]) < 0)
{
else
{
/* this entry goes in a column of L */
- DEBUG1 (("Singleton col of L: k "ID" newrow "ID"\n",
+ DEBUG1 (("Singleton col of L: k " ID " newrow " ID "\n",
k, newrow)) ;
if (llen >= lilen)
{
if (newrow < n1 || rdeg > dense_row_threshold)
{
/* this entry goes in a row of U or into a dense row */
- DEBUG1 (("Singleton/dense row of U: k "ID" newrow "ID"\n",
+ DEBUG1 (("Singleton/dense row of U: k " ID " newrow " ID "\n",
k, newrow)) ;
if (--(Wp [newrow]) < 0)
{
else
{
/* this entry goes in an initial element */
- DEBUG1 (("In element k "ID" e "ID" newrow "ID"\n",
+ DEBUG1 (("In element k " ID " e " ID " newrow " ID "\n",
k, e, newrow)) ;
if (clen >= esize)
{
#ifndef NDEBUG
if (Diagonal_map && (newrow == Diagonal_map [k]))
{
- DEBUG0 (("Diagonal: old: row "ID" col "ID" : "
- "new: row "ID" col "ID" : ",
+ DEBUG0 (("Diagonal: old: row " ID " col " ID " : "
+ "new: row " ID " col " ID " : ",
oldrow, oldcol, newrow, k)) ;
EDEBUGk (0, x) ;
}
ASSERT (pnew == 1) ;
for (k = 0 ; k < n1 ; k++)
{
- DEBUGm4 (("\nPrune singleton L col "ID"\n", k)) ;
+ DEBUGm4 (("\nPrune singleton L col " ID "\n", k)) ;
pnew = packsp (pnew, &Lip [k], &Lilen [k], drop, droptol, Memory) ;
Numeric->lnz += Lilen [k] ;
- DEBUGm4 (("\nPrune singleton U row "ID"\n", k)) ;
+ DEBUGm4 (("\nPrune singleton U row " ID "\n", k)) ;
pnew = packsp (pnew, &Uip [k], &Uilen [k], drop, droptol, Memory) ;
Numeric->unz += Uilen [k] ;
}
for (k = n1 ; k < n_row ; k++)
{
- DEBUG1 (("Initial row degree k "ID" oldrow "ID" Rdeg "ID"\n",
+ DEBUG1 (("Initial row degree k " ID " oldrow " ID " Rdeg " ID "\n",
k, Rperm_init [k], Rdeg [k])) ;
rdeg = Rdeg [k] ;
Row_degree [k] = rdeg ;
ASSIGN (aij, Ax, Az, p, split) ;
if (newrow == Diagonal_map [newcol])
{
- DEBUG0 (("old row "ID" col "ID" new row "ID" col "ID,
+ DEBUG0 (("old row " ID " col " ID " new row " ID " col " ID,
oldrow, oldcol, newrow, newcol)) ;
EDEBUGk (0, aij) ;
DEBUG0 ((" scaled ")) ;
}
#ifndef NDEBUG
- DEBUG0 (("Number of initial elements: "ID"\n", Work->nel)) ;
+ DEBUG0 (("Number of initial elements: " ID "\n", Work->nel)) ;
for (e = 0 ; e <= Work->nel ; e++) UMF_dump_element (Numeric, Work,e,TRUE) ;
#endif
Wp [i] = EMPTY ;
}
- DEBUG1 (("Kernel init head usage: "ID"\n", Numeric->ihead)) ;
+ DEBUG1 (("Kernel init head usage: " ID "\n", Numeric->ihead)) ;
/* ---------------------------------------------------------------------- */
/* build the tuple lists */
ASSERT (n_row == Numeric->n_row) ;
ASSERT (n_col == Symbolic->n_col) ;
- DEBUG0 (("Wrap-up: npiv "ID" ulen "ID"\n", npiv, Numeric->ulen)) ;
+ 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 */
{
/* finalize the row permutation */
k = npiv ;
- DEBUGm3 (("Singular pivot rows "ID" to "ID"\n", k, n_row-1)) ;
+ 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)) ;
+ DEBUGm3 (("Singular row " ID " is k: " ID " pivot row\n", row, k)) ;
ASSERT (!NON_PIVOTAL_ROW (row)) ;
Lpos [row] = EMPTY ;
Uip [row] = EMPTY ;
{
/* finalize the col permutation */
k = npiv ;
- DEBUGm3 (("Singular pivot cols "ID" to "ID"\n", k, n_col-1)) ;
+ 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)) ;
+ DEBUGm3 (("Singular col " ID " is k: " ID " pivot row\n", col, k)) ;
ASSERT (!NON_PIVOTAL_COL (col)) ;
Upos [col] = EMPTY ;
Lip [col] = EMPTY ;
if (npiv < n_inner)
{
/* finalize the diagonal of U */
- DEBUGm3 (("Diag of U is zero, "ID" to "ID"\n", npiv, n_inner-1)) ;
+ DEBUGm3 (("Diag of U is zero, " ID " to " ID "\n", npiv, n_inner-1)) ;
for (k = npiv ; k < n_inner ; k++)
{
CLEAR (D [k]) ;
Work->Upattern = (Int *) NULL ;
}
- DEBUG2 (("Nnzpiv: "ID" npiv "ID"\n", Numeric->nnzpiv, npiv)) ;
+ DEBUG2 (("Nnzpiv: " ID " npiv " ID "\n", Numeric->nnzpiv, npiv)) ;
ASSERT (Numeric->nnzpiv <= npiv) ;
if (Numeric->nnzpiv < n_inner && !SCALAR_IS_NAN (Numeric->min_udiag))
{
{
/* this is a singleton row of U */
ulen = Uilen [k] ;
- DEBUG4 (("K "ID" New U. ulen "ID" Singleton 1\n", k, ulen)) ;
+ DEBUG4 (("K " ID " New U. ulen " ID " Singleton 1\n", k, ulen)) ;
if (ulen > 0)
{
up = Uip [k] ;
for (i = 0 ; i < ulen ; i++)
{
col = *ip ;
- DEBUG4 ((" old col "ID" new col "ID"\n", col, Fcpos [col]));
+ DEBUG4 ((" old col " ID " new col " ID "\n", col, Fcpos [col]));
ASSERT (col >= 0 && col < n_col) ;
*ip++ = Fcpos [col] ;
}
{
/* 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)) ;
+ DEBUG4 (("K " ID " New U. ulen " ID " End_Uchain 1\n", k, ulen)) ;
if (ulen > 0)
{
up = -up ;
for (i = 0 ; i < ulen ; i++)
{
col = *ip ;
- DEBUG4 ((" old col "ID" new col "ID"\n", col, Fcpos [col]));
+ DEBUG4 ((" old col " ID " new col " ID "\n", col, Fcpos [col]));
ASSERT (col >= 0 && col < n_col) ;
*ip++ = Fcpos [col] ;
}
if (ulen > 0)
{
/* convert last pivot row of U to the new pivot order */
- DEBUG4 (("K "ID" (last)\n", k)) ;
+ 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])) ;
+ DEBUG4 ((" old col " ID " new col " ID "\n", col, Fcpos [col])) ;
Numeric->Upattern [i] = Fcpos [col] ;
}
}
for (k = 0 ; k < n1 ; k++)
{
llen = Lilen [k] ;
- DEBUG4 (("K "ID" New L. llen "ID" Singleton col\n", k, llen)) ;
+ DEBUG4 (("K " ID " New L. llen " ID " Singleton col\n", k, llen)) ;
if (llen > 0)
{
lp = Lip [k] ;
for (i = 0 ; i < llen ; i++)
{
row = *ip ;
- DEBUG4 ((" old row "ID" new row "ID"\n", row, Frpos [row])) ;
+ 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)) ;
+ DEBUG4 (("K " ID " New L. llen " ID " \n", k, llen)) ;
if (llen > 0)
{
lp = Lip [k] ;
for (i = 0 ; i < llen ; i++)
{
row = *ip ;
- DEBUG4 ((" old row "ID" new row "ID"\n", row, Frpos [row])) ;
+ DEBUG4 ((" old row " ID " new row " ID "\n", row, Frpos [row])) ;
ASSERT (row >= 0 && row < n_row) ;
*ip++ = Frpos [row] ;
}
#ifndef NDEBUG
Int j ;
- DEBUGm2 (("pivot column Candidates before remove: nCand "ID" ncand "ID
- " lo "ID" hi "ID" jj "ID"\n", Work->nCandidates, Work->ncand,
+ DEBUGm2 (("pivot column Candidates before remove: nCand " ID " ncand " ID
+ " lo " ID " hi " ID " jj " ID "\n", Work->nCandidates, Work->ncand,
Work->lo, Work->hi, jj)) ;
for (j = 0 ; j < Work->nCandidates ; j++)
{
Int col = Work->Candidates [j] ;
- DEBUGm2 ((ID" ", col));
+ DEBUGm2 ((ID " ", col));
ASSERT (col >= 0 && col < Work->n_col) ;
/* ASSERT (NON_PIVOTAL_COL (col)) ; */
ASSERT (col >= Work->lo && col <= Work->hi) ;
Work->ncand-- ;
#ifndef NDEBUG
- DEBUGm2 (("pivot column Candidates after remove: nCand "ID" ncand "ID
- " lo "ID" hi "ID" jj "ID"\n", Work->nCandidates, Work->ncand, Work->lo,
+ DEBUGm2 (("pivot column Candidates after remove: nCand " ID " ncand " ID
+ " lo " ID " hi " ID " jj " ID "\n", Work->nCandidates, Work->ncand, Work->lo,
Work->hi, jj)) ;
for (j = 0 ; j < Work->nCandidates ; j++)
{
Int col = Work->Candidates [j] ;
- DEBUGm2 ((ID" ", col));
+ DEBUGm2 ((ID " ", col));
ASSERT (col >= 0 && col < Work->n_col) ;
/* ASSERT (NON_PIVOTAL_COL (col)) ; */
ASSERT (col >= Work->lo && col <= Work->hi) ;
}
}
- DEBUGm2 ((ID" pivot column Candidates: lo "ID" hi "ID"\n",
+ DEBUGm2 ((ID " pivot column Candidates: lo " ID " hi " ID "\n",
Work->nCandidates, Work->lo, Work->hi)) ;
for (j = 0 ; j < Work->nCandidates ; j++)
{
col = Work->Candidates [j] ;
- DEBUGm2 ((ID" ", col));
+ DEBUGm2 ((ID " ", col));
ASSERT (col >= 0 && col < n_col) ;
ASSERT (NON_PIVOTAL_COL (col)) ;
ASSERT (col >= Work->lo && col <= Work->hi) ;
DEBUGm2 (("\n")) ;
/* there are no 0-by-c or r-by-0 fronts, where c and r are > 0 */
/* a front is either 0-by-0, or r-by-c */
- DEBUG2 (("\n\n::: "ID" : Npiv: "ID" + fnpiv "ID" = "ID". "
- "size "ID"-by-"ID"\n", Work->frontid,
+ DEBUG2 (("\n\n::: " ID " : Npiv: " ID " + fnpiv " ID " = " ID ". "
+ "size " ID "-by-" ID "\n", Work->frontid,
Work->npiv, Work->fnpiv, Work->npiv + Work->fnpiv, fnrows, fncols)) ;
ASSERT ((fnrows == 0 && fncols == 0) ||(fnrows != 0 && fncols != 0)) ;
#endif
#ifndef NDEBUG
/* check Frpos */
- DEBUG4 (("Check Frpos : fnrows "ID" col "ID" maxcdeg "ID"\n",
+ DEBUG4 (("Check Frpos : fnrows " ID " col " ID " maxcdeg " ID "\n",
fnrows, pivcol [IN], max_cdeg)) ;
for (i = 0 ; i < fnrows ; i++)
{
row = Frows [i] ;
- DEBUG4 ((" row: "ID"\n", row)) ;
+ DEBUG4 ((" row: " ID "\n", row)) ;
ASSERT (row >= 0 && row < n_row) ;
ASSERT (Frpos [row] == i) ;
}
}
else
{
- DEBUG4 ((" row: "ID" pos "ID"\n", row, Frpos [row])) ;
+ DEBUG4 ((" row: " ID " pos " ID "\n", row, Frpos [row])) ;
}
}
ASSERT (cnt == n_row) ;
/* look in the candidate set for the best column */
/* ------------------------------------------------------------------ */
- DEBUG2 (("Max candidates %d, Work->ncand "ID" jmax "ID"\n",
+ DEBUG2 (("Max candidates %d, Work->ncand " ID " jmax " ID "\n",
MAX_CANDIDATES, Work->ncand, Work->nCandidates)) ;
col = Work->Candidates [0] ;
ASSERT (Work->nCandidates > 0) ;
- DEBUG3 (("Pivot column candidate: "ID" j = "ID"\n", col, j)) ;
+ DEBUG3 (("Pivot column candidate: " ID " j = " ID "\n", col, j)) ;
ASSERT (col >= 0 && col < n_col) ;
/* there is no Col_degree if fixQ is true */
deg = Symbolic->fixQ ? EMPTY : Col_degree [col] ;
#ifndef NDEBUG
- DEBUG3 (("Pivot column candidate: "ID" cost: "ID" Fcpos[col] "ID"\n",
+ DEBUG3 (("Pivot column candidate: " ID " cost: " ID " Fcpos[col] " ID "\n",
col, deg, Fcpos [col])) ;
UMF_dump_rowcol (1, Numeric, Work, col, !Symbolic->fixQ) ;
if (Symbolic->fixQ)
{
- DEBUG1 (("FIXQ: Candidates "ID" pivcol "ID" npiv "ID" fnpiv "ID
- " ndiscard "ID "\n", Work->nCandidates, col, Work->npiv,
+ DEBUG1 (("FIXQ: Candidates " ID " pivcol " ID " npiv " ID " fnpiv " ID
+ " ndiscard " ID "\n", Work->nCandidates, col, Work->npiv,
Work->fnpiv, Work->ndiscard)) ;
ASSERT (Work->nCandidates == 1) ;
ASSERT (col == Work->npiv + Work->fnpiv + Work->ndiscard) ;
{
col = Work->Candidates [j] ;
- DEBUG3 (("Pivot col candidate: "ID" j = "ID"\n", col, j)) ;
+ DEBUG3 (("Pivot col candidate: " ID " j = " ID "\n", col, j)) ;
ASSERT (col >= 0 && col < n_col) ;
ASSERT (!Symbolic->fixQ) ;
deg = Col_degree [col] ;
#ifndef NDEBUG
- DEBUG3 (("Pivot col candidate: "ID" cost: "ID" Fcpos[col] "ID"\n",
+ DEBUG3 (("Pivot col candidate: " ID " cost: " ID " Fcpos[col] " ID "\n",
col, deg, Fcpos [col])) ;
UMF_dump_rowcol (1, Numeric, Work, col, !Symbolic->fixQ) ;
#endif
}
}
- DEBUG2 (("Pivcol in "ID" out "ID"\n", pivcol [IN], pivcol [OUT])) ;
+ DEBUG2 (("Pivcol in " ID " out " ID "\n", pivcol [IN], pivcol [OUT])) ;
ASSERT ((pivcol [IN] >= 0 && pivcol [IN] < n_col)
|| (pivcol [OUT] >= 0 && pivcol [OUT] < n_col)) ;
#ifndef NDEBUG
/* check Frpos */
- DEBUG4 (("Prior to col update: fnrows "ID" col "ID" maxcdeg "ID"\n",
+ DEBUG4 (("Prior to col update: fnrows " ID " col " ID " maxcdeg " ID "\n",
fnrows, pivcol [IN], max_cdeg)) ;
for (i = 0 ; i < fnrows ; i++)
{
row = Frows [i] ;
- DEBUG4 ((" row: "ID"\n", row)) ;
+ DEBUG4 ((" row: " ID "\n", row)) ;
ASSERT (row >= 0 && row < n_row) ;
ASSERT (Frpos [row] == i) ;
}
}
else
{
- DEBUG4 ((" row: "ID" pos "ID"\n", row, Frpos [row])) ;
+ DEBUG4 ((" row: " ID " pos " ID "\n", row, Frpos [row])) ;
}
}
ASSERT (cnt == n_row) ;
{
#ifndef NDEBUG
- DEBUG2 (("col[IN] column "ID" in front at position = "ID"\n",
+ DEBUG2 (("col[IN] column " ID " in front at position = " ID "\n",
pivcol [IN], Fcpos [pivcol [IN]])) ;
UMF_dump_rowcol (1, Numeric, Work, pivcol [IN], !Symbolic->fixQ) ;
#endif
/* ------------------------------------------------------------------ */
#ifndef NDEBUG
- DEBUG2 (("Wy after update: fnrows="ID"\n", fnrows)) ;
- DEBUG4 ((" fnpiv="ID" \n", fnpiv)) ;
+ DEBUG2 (("Wy after update: fnrows=" ID "\n", fnrows)) ;
+ DEBUG4 ((" fnpiv=" ID " \n", fnpiv)) ;
for (i = 0 ; i < fnrows ; i++)
{
- DEBUG4 ((ID" "ID" "ID, i, Frows [i], Frpos [Frows [i]])) ;
+ DEBUG4 ((ID " " ID " " ID, i, Frows [i], Frpos [Frows [i]])) ;
EDEBUG4 (Wy [i]) ;
DEBUG4 (("\n")) ;
}
#ifndef NDEBUG
/* check Frpos */
- DEBUG4 (("After col update: fnrows "ID" col "ID" maxcdeg "ID"\n",
+ DEBUG4 (("After col update: fnrows " ID " col " ID " maxcdeg " ID "\n",
fnrows, pivcol [IN], max_cdeg)) ;
for (i = 0 ; i < fnrows ; i++)
{
row = Frows [i] ;
- DEBUG4 ((" row: "ID"\n", row)) ;
+ DEBUG4 ((" row: " ID "\n", row)) ;
ASSERT (row >= 0 && row < n_row) ;
ASSERT (Frpos [row] == i) ;
}
}
else
{
- DEBUG4 ((" row: "ID" pos "ID"\n", row, Frpos [row])) ;
+ DEBUG4 ((" row: " ID " pos " ID "\n", row, Frpos [row])) ;
}
}
ASSERT (cnt == n_row) ;
#ifndef NDEBUG
/* check Frpos */
- DEBUG4 (("COL ASSEMBLE: cdeg "ID"\nREDUCE COL in "ID" max_cdeg "ID"\n",
+ DEBUG4 (("COL ASSEMBLE: cdeg " ID "\nREDUCE COL in " ID " max_cdeg " ID "\n",
cdeg_in, pivcol [IN], max_cdeg)) ;
for (i = 0 ; i < cdeg_in ; i++)
{
#ifndef NDEBUG
/* check Frpos again */
- DEBUG4 (("COL DONE: cdeg "ID"\nREDUCE COL in "ID" max_cdeg "ID"\n",
+ DEBUG4 (("COL DONE: cdeg " ID "\nREDUCE COL in " ID " max_cdeg " ID "\n",
cdeg_in, pivcol [IN], max_cdeg)) ;
for (i = 0 ; i < cdeg_in ; i++)
{
#endif
#ifndef NDEBUG
- DEBUG4 (("Reduced column: cdeg in "ID" fnrows_max "ID"\n",
+ DEBUG4 (("Reduced column: cdeg in " ID " fnrows_max " ID "\n",
cdeg_in, Work->fnrows_max)) ;
for (i = 0 ; i < cdeg_in ; i++)
{
- DEBUG4 ((" "ID" "ID" "ID, i, Frows [i], Frpos [Frows [i]])) ;
+ DEBUG4 ((" " ID " " ID " " ID, i, Frows [i], Frpos [Frows [i]])) ;
EDEBUG4 (Wy [i]) ;
DEBUG4 (("\n")) ;
ASSERT (i == Frpos [Frows [i]]) ;
do_extend = TRUE ;
DEBUG2 (("Evaluating option IN-IN:\n")) ;
- DEBUG2 (("Work->fnzeros "ID" fnpiv "ID" nr_in "ID" nc "ID"\n",
+ DEBUG2 (("Work->fnzeros " ID " fnpiv " ID " nr_in " ID " nc " ID "\n",
Work->fnzeros, fnpiv, nr_in, nc)) ;
- DEBUG2 (("fncols "ID" fnrows "ID"\n", fncols, fnrows)) ;
+ DEBUG2 (("fncols " ID " fnrows " ID "\n", fncols, fnrows)) ;
/* determine if BLAS-3 update should be applied before extending. */
/* update if too many zero entries accumulate in the LU block */
fnzeros = Work->fnzeros + fnpiv * (nr_in + nc) ;
- DEBUG2 (("fnzeros "ID"\n", fnzeros)) ;
+ DEBUG2 (("fnzeros " ID "\n", fnzeros)) ;
new_LUsize = (fnpiv+1) * (fnrows + nr_in + fncols + nc) ;
- DEBUG2 (("new_LUsize "ID"\n", new_LUsize)) ;
+ DEBUG2 (("new_LUsize " ID "\n", new_LUsize)) ;
/* There are fnpiv pivots currently in the front. This one
* will be the (fnpiv+1)st pivot, if it is extended. */
do_update = fnpiv > 0 &&
(((double) fnzeros) / ((double) new_LUsize)) > RELAX2 ;
- DEBUG2 (("do_update "ID"\n", do_update))
+ DEBUG2 (("do_update " ID "\n", do_update))
- DEBUG2 (("option IN IN : nr "ID" nc "ID" cost "ID"(0) relax "ID
+ DEBUG2 (("option IN IN : nr " ID " nc " ID " cost " ID "(0) relax " ID
"\n", nr_in, nc, thiscost, do_extend)) ;
/* this is the best option seen so far */
for (i = 0 ; i < rdeg [IN][OUT] ; i++)
{
col = Wio [i] ;
- DEBUG4 (("counting col "ID" Fcpos[] = "ID"\n", col,
+ DEBUG4 (("counting col " ID " Fcpos[] = " ID "\n", col,
Fcpos [col])) ;
ASSERT (col >= 0 && col < n_col && NON_PIVOTAL_COL (col)) ;
if (Fcpos [col] < 0) nc++ ;
thiscost += extra_zeros ;
DEBUG2 (("Evaluating option IN-OUT:\n")) ;
- DEBUG2 (("Work->fnzeros "ID" fnpiv "ID" nr_in "ID" nc "ID"\n",
+ DEBUG2 (("Work->fnzeros " ID " fnpiv " ID " nr_in " ID " nc " ID "\n",
Work->fnzeros, fnpiv, nr_in, nc)) ;
- DEBUG2 (("fncols "ID" fnrows "ID"\n", fncols, fnrows)) ;
+ DEBUG2 (("fncols " ID " fnrows " ID "\n", fncols, fnrows)) ;
/* determine if BLAS-3 update to be applied before extending. */
/* update if too many zero entries accumulate in the LU block */
fnzeros = Work->fnzeros + fnpiv * (nr_in + nc) ;
- DEBUG2 (("fnzeros "ID"\n", fnzeros)) ;
+ DEBUG2 (("fnzeros " ID "\n", fnzeros)) ;
new_LUsize = (fnpiv+1) * (fnrows + nr_in + fncols + nc) ;
- DEBUG2 (("new_LUsize "ID"\n", new_LUsize)) ;
+ DEBUG2 (("new_LUsize " ID "\n", new_LUsize)) ;
/* RELAX3 parameter uses a double relop, ignore NaN case: */
do_update = fnpiv > 0 &&
(((double) fnzeros) / ((double) new_LUsize)) > RELAX3 ;
- DEBUG2 (("do_update "ID"\n", do_update))
+ DEBUG2 (("do_update " ID "\n", do_update))
}
else
/* the current front would not be extended */
do_update = fnpiv > 0 ;
fnzeros = 0 ;
- DEBUG2 (("IN-OUT do_update forced true: "ID"\n", do_update)) ;
+ DEBUG2 (("IN-OUT do_update forced true: " ID "\n", do_update)) ;
/* The new front would be just big enough to hold the new
* pivot row and column. */
}
- DEBUG2 (("option IN OUT: nr "ID" nc "ID" cost "ID"("ID") relax "ID
+ DEBUG2 (("option IN OUT: nr " ID " nc " ID " cost " ID "(" ID ") relax " ID
"\n", nr_in, nc, thiscost, extra_zeros, do_extend)) ;
if (bestcost == EMPTY || thiscost < bestcost)
{
#ifndef NDEBUG
- DEBUG2 (("out_col column "ID" NOT in front at position = "ID"\n",
+ DEBUG2 (("out_col column " ID " NOT in front at position = " ID "\n",
pivcol [OUT], Fcpos [pivcol [OUT]])) ;
UMF_dump_rowcol (1, Numeric, Work, pivcol [OUT], !Symbolic->fixQ) ;
- DEBUG2 (("fncols "ID" fncols_max "ID"\n", fncols, Work->fncols_max)) ;
+ DEBUG2 (("fncols " ID " fncols_max " ID "\n", fncols, Work->fncols_max)) ;
ASSERT (fncols < Work->fncols_max) ;
#endif
#ifndef NDEBUG
/* check Wp */
- DEBUG4 (("COL ASSEMBLE: cdeg 0\nREDUCE COL out "ID"\n", pivcol [OUT])) ;
+ DEBUG4 (("COL ASSEMBLE: cdeg 0\nREDUCE COL out " ID "\n", pivcol [OUT])) ;
if (UMF_debug > 0 || MAX (n_row, n_col) < 1000)
{
for (i = 0 ; i < MAX (n_row, n_col) ; i++)
ASSERT (Wp [i] < 0) ;
}
}
- DEBUG4 (("max_cdeg: "ID"\n", max_cdeg)) ;
+ DEBUG4 (("max_cdeg: " ID "\n", max_cdeg)) ;
#endif
ASSERT (pivcol [OUT] >= 0 && pivcol [OUT] < n_col) ;
/* ------------------------------------------------------------------ */
#ifndef NDEBUG
- DEBUG4 (("Reduced column: cdeg out "ID"\n", cdeg_out)) ;
+ DEBUG4 (("Reduced column: cdeg out " ID "\n", cdeg_out)) ;
for (i = 0 ; i < cdeg_out ; i++)
{
- DEBUG4 ((" "ID" "ID" "ID, i, Wm [i], Wp [Wm [i]])) ;
+ DEBUG4 ((" " ID " " ID " " ID, i, Wm [i], Wp [Wm [i]])) ;
EDEBUG4 (Wx [i]) ;
DEBUG4 (("\n")) ;
ASSERT (i == Wp [Wm [i]]) ;
* the current front is empty, pivcol [IN] must also be EMPTY.
*/
- DEBUGm4 (("Note: pivcol [OUT]: "ID" discard\n", pivcol [OUT])) ;
+ DEBUGm4 (("Note: pivcol [OUT]: " ID " discard\n", pivcol [OUT])) ;
ASSERT ((Work->fnrows == 0 && Work->fncols == 0)) ;
ASSERT (pivcol [IN] == EMPTY) ;
Work->ndiscard++ ;
/* delete all of the tuples, and all contributions to this column */
- DEBUG1 (("Prune tuples of dead outcol: "ID"\n", pivcol [OUT])) ;
+ DEBUG1 (("Prune tuples of dead outcol: " ID "\n", pivcol [OUT])) ;
Col_tlen [pivcol [OUT]] = 0 ;
UMF_mem_free_tail_block (Numeric, Col_tuples [pivcol [OUT]]) ;
Col_tuples [pivcol [OUT]] = 0 ;
/* the "in" row is the same as the "in" row for the "in" column */
Woi = Fcols ;
rdeg [OUT][IN] = rdeg [IN][IN] ;
- DEBUG4 (("Freebie in, row "ID"\n", pivrow [IN][IN])) ;
+ DEBUG4 (("Freebie in, row " ID "\n", pivrow [IN][IN])) ;
}
if (freebie [OUT])
/* the "out" row is the same as the "out" row for the "in" column */
Woo = Wio ;
rdeg [OUT][OUT] = rdeg [IN][OUT] ;
- DEBUG4 (("Freebie out, row "ID"\n", pivrow [IN][OUT])) ;
+ DEBUG4 (("Freebie out, row " ID "\n", pivrow [IN][OUT])) ;
}
/* ------------------------------------------------------------------ */
thiscost += extra_zeros ;
DEBUG2 (("Evaluating option OUT-IN:\n")) ;
- DEBUG2 ((" Work->fnzeros "ID" fnpiv "ID" nr_out "ID" nc "ID"\n",
+ DEBUG2 ((" Work->fnzeros " ID " fnpiv " ID " nr_out " ID " nc " ID "\n",
Work->fnzeros, fnpiv, nr_out, nc)) ;
- DEBUG2 (("fncols "ID" fnrows "ID"\n", fncols, fnrows)) ;
+ DEBUG2 (("fncols " ID " fnrows " ID "\n", fncols, fnrows)) ;
/* determine if BLAS-3 update to be applied before extending. */
/* update if too many zero entries accumulate in the LU block */
fnzeros = Work->fnzeros + fnpiv * (nr_out + nc) ;
- DEBUG2 (("fnzeros "ID"\n", fnzeros)) ;
+ DEBUG2 (("fnzeros " ID "\n", fnzeros)) ;
new_LUsize = (fnpiv+1) * (fnrows + nr_out + fncols + nc) ;
- DEBUG2 (("new_LUsize "ID"\n", new_LUsize)) ;
+ DEBUG2 (("new_LUsize " ID "\n", new_LUsize)) ;
/* RELAX3 parameter uses a double relop, ignore NaN case: */
do_update = fnpiv > 0 &&
(((double) fnzeros) / ((double) new_LUsize)) > RELAX3 ;
- DEBUG2 (("do_update "ID"\n", do_update))
+ DEBUG2 (("do_update " ID "\n", do_update))
}
else
{
/* the current front would not be extended */
do_update = fnpiv > 0 ;
fnzeros = 0 ;
- DEBUG2 (("OUT-IN do_update forced true: "ID"\n", do_update)) ;
+ DEBUG2 (("OUT-IN do_update forced true: " ID "\n", do_update)) ;
/* The new front would be just big enough to hold the new
* pivot row and column. */
fncols_new [OUT][IN] = rdeg [OUT][IN] - 1 ;
}
- DEBUG2 (("option OUT IN : nr "ID" nc "ID" cost "ID"("ID") relax "ID
+ DEBUG2 (("option OUT IN : nr " ID " nc " ID " cost " ID "(" ID ") relax " ID
"\n", nr_out, nc, thiscost, extra_zeros, do_extend)) ;
if (bestcost == EMPTY || thiscost < bestcost)
thiscost += extra_zeros ;
DEBUG2 (("Evaluating option OUT-OUT:\n")) ;
- DEBUG2 (("Work->fnzeros "ID" fnpiv "ID" nr_out "ID" nc "ID"\n",
+ DEBUG2 (("Work->fnzeros " ID " fnpiv " ID " nr_out " ID " nc " ID "\n",
Work->fnzeros, fnpiv, nr_out, nc)) ;
- DEBUG2 (("fncols "ID" fnrows "ID"\n", fncols, fnrows)) ;
+ DEBUG2 (("fncols " ID " fnrows " ID "\n", fncols, fnrows)) ;
/* determine if BLAS-3 update to be applied before extending. */
/* update if too many zero entries accumulate in the LU block */
fnzeros = Work->fnzeros + fnpiv * (nr_out + nc) ;
- DEBUG2 (("fnzeros "ID"\n", fnzeros)) ;
+ DEBUG2 (("fnzeros " ID "\n", fnzeros)) ;
new_LUsize = (fnpiv+1) * (fnrows + nr_out + fncols + nc) ;
- DEBUG2 (("new_LUsize "ID"\n", new_LUsize)) ;
+ DEBUG2 (("new_LUsize " ID "\n", new_LUsize)) ;
/* RELAX3 parameter uses a double relop, ignore NaN case: */
do_update = fnpiv > 0 &&
(((double) fnzeros) / ((double) new_LUsize)) > RELAX3 ;
- DEBUG2 (("do_update "ID"\n", do_update))
+ DEBUG2 (("do_update " ID "\n", do_update))
}
else
{
/* the current front would not be extended */
do_update = fnpiv > 0 ;
fnzeros = 0 ;
- DEBUG2 (("OUT-OUT do_update forced true: "ID"\n", do_update)) ;
+ DEBUG2 (("OUT-OUT do_update forced true: " ID "\n", do_update)) ;
/* The new front would be just big enough to hold the new
* pivot row and column. */
fncols_new [OUT][OUT] = rdeg [OUT][OUT] - 1 ;
}
- DEBUG2 (("option OUT OUT: nr "ID" nc "ID" cost "ID"\n",
+ DEBUG2 (("option OUT OUT: nr " ID " nc " ID " cost " ID "\n",
rdeg [OUT][OUT], cdeg_out, thiscost)) ;
if (bestcost == EMPTY || thiscost < bestcost)
/* At this point, a structural pivot has been found. */
/* It may be numerically zero, however. */
ASSERT (Work->pivot_case != EMPTY) ;
- DEBUG2 (("local search, best option "ID", best cost "ID"\n",
+ DEBUG2 (("local search, best option " ID ", best cost " ID "\n",
Work->pivot_case, bestcost)) ;
/* ====================================================================== */
/* ---------------------------------------------------------------------- */
DEBUG1 (("Check frontal growth:\n")) ;
- DEBUG1 (("fnrows_new "ID" + 1 = "ID", fnr_curr "ID"\n",
+ DEBUG1 (("fnrows_new " ID " + 1 = " ID ", fnr_curr " ID "\n",
Work->fnrows_new, Work->fnrows_new + 1, fnr_curr)) ;
- DEBUG1 (("fncols_new "ID" + 1 = "ID", fnc_curr "ID"\n",
+ DEBUG1 (("fncols_new " ID " + 1 = " ID ", fnc_curr " ID "\n",
Work->fncols_new, Work->fncols_new + 1, fnc_curr)) ;
Work->do_grow = (Work->fnrows_new + 1 > fnr_curr
#ifndef NDEBUG
- DEBUG2 (("\n\nSEARCH DONE: Pivot col "ID" in: ("ID") pivot row "ID" in: ("ID
- ") extend: "ID"\n\n", Work->pivcol, Work->pivcol_in_front,
+ DEBUG2 (("\n\nSEARCH DONE: Pivot col " ID " in: (" ID ") pivot row " ID " in: (" ID
+ ") extend: " ID "\n\n", Work->pivcol, Work->pivcol_in_front,
Work->pivrow, Work->pivrow_in_front, Work->do_extend)) ;
UMF_dump_rowcol (1, Numeric, Work, Work->pivcol, !Symbolic->fixQ) ;
- DEBUG2 (("Pivot col "ID": fnrows "ID" ccdeg "ID"\n", Work->pivcol, fnrows,
+ DEBUG2 (("Pivot col " ID ": fnrows " ID " ccdeg " ID "\n", Work->pivcol, fnrows,
Work->ccdeg)) ;
if (Work->pivcol_in_front) /* case c1 */
{
for (i = 0 ; i < fnrows ; i++)
{
row = Frows [i] ;
- DEBUG3 ((ID": row:: "ID" in front ", i, row)) ;
+ DEBUG3 ((ID ": row:: " ID " in front ", i, row)) ;
ASSERT (row >= 0 && row < n_row && NON_PIVOTAL_ROW (row)) ;
ASSERT (Frpos [row] == i) ;
EDEBUG3 (Wy [i]) ;
for (i = fnrows ; i < fnrows + Work->ccdeg ; i++)
{
row = Frows [i] ;
- DEBUG3 ((ID": row:: "ID" (new)", i, row)) ;
+ DEBUG3 ((ID ": row:: " ID " (new)", i, row)) ;
ASSERT (row >= 0 && row < n_row && NON_PIVOTAL_ROW (row)) ;
ASSERT (Frpos [row] == i) ;
EDEBUG3 (Wy [i]) ;
for (i = 0 ; i < fnrows ; i++)
{
row = Frows [i] ;
- DEBUG3 ((ID": row:: "ID" in front ", i, row)) ;
+ DEBUG3 ((ID ": row:: " ID " in front ", i, row)) ;
ASSERT (row >= 0 && row < n_row && NON_PIVOTAL_ROW (row)) ;
ASSERT (Frpos [row] == i) ;
if (row == Work->pivrow)
{
row = Wm [i] ;
ASSERT (row >= 0 && row < n_row && NON_PIVOTAL_ROW (row)) ;
- DEBUG3 ((ID": row:: "ID" ", i, row)) ;
+ DEBUG3 ((ID ": row:: " ID " ", i, row)) ;
EDEBUG3 (Wx [i]) ;
if (Frpos [row] < 0)
{
{
row = Wm [i] ;
ASSERT (row >= 0 && row < n_row && NON_PIVOTAL_ROW (row)) ;
- DEBUG3 ((ID": row:: "ID" ", i, row)) ;
+ DEBUG3 ((ID ": row:: " ID " ", i, row)) ;
EDEBUG3 (Wx [i]) ;
DEBUG3 ((" (new) ")) ;
if (row == Work->pivrow)
#ifndef NDEBUG
UMF_dump_rowcol (0, Numeric, Work, Work->pivrow, TRUE) ;
- DEBUG2 (("Pivot row "ID":\n", Work->pivrow)) ;
+ DEBUG2 (("Pivot row " ID ":\n", Work->pivrow)) ;
if (Work->pivrow_in_front)
{
Int found = FALSE ;
for (i = 0 ; i < fncols ; i++)
{
col = Fcols [i] ;
- DEBUG3 ((" col:: "ID" in front\n", col)) ;
+ DEBUG3 ((" col:: " ID " in front\n", col)) ;
ASSERT (col >= 0 && col < n_col && NON_PIVOTAL_COL (col)) ;
ASSERT (Fcpos [col] == i * fnr_curr) ;
if (col == Work->pivcol) found = TRUE ;
ASSERT (col >= 0 && col < n_col && NON_PIVOTAL_COL (col)) ;
ASSERT (Fcpos [col] < 0) ;
if (col == Work->pivcol) found = TRUE ;
- else DEBUG3 ((" col:: "ID" (new)\n", col)) ;
+ else DEBUG3 ((" col:: " ID " (new)\n", col)) ;
}
ASSERT (found == !Work->pivcol_in_front) ;
}
for (i = 0 ; i < fncols ; i++)
{
col = Fcols [i] ;
- DEBUG3 ((" col:: "ID" in front\n", col)) ;
+ DEBUG3 ((" col:: " ID " in front\n", col)) ;
ASSERT (col >= 0 && col < n_col && NON_PIVOTAL_COL (col)) ;
ASSERT (Fcpos [col] == i * fnr_curr) ;
if (col == Work->pivcol) found = TRUE ;
ASSERT (col >= 0 && col < n_col && NON_PIVOTAL_COL (col)) ;
if (Fcpos [col] >= 0) continue ;
if (col == Work->pivcol) found = TRUE ;
- else DEBUG3 ((" col:: "ID" (new, extend)\n", col)) ;
+ else DEBUG3 ((" col:: " ID " (new, extend)\n", col)) ;
}
ASSERT (found == !Work->pivcol_in_front) ;
}
col = Work->Wrow [i] ;
ASSERT (col >= 0 && col < n_col && NON_PIVOTAL_COL (col)) ;
if (col == Work->pivcol) found = TRUE ;
- else DEBUG3 ((" col:: "ID" (all new)\n", col)) ;
+ else DEBUG3 ((" col:: " ID " (all new)\n", col)) ;
}
ASSERT (found) ;
}
/* ---------------------------------------------------------------------- */
- DEBUG2 (("LOCAL SEARCH DONE: pivot column "ID" pivot row: "ID"\n",
+ DEBUG2 (("LOCAL SEARCH DONE: pivot column " ID " pivot row: " ID "\n",
Work->pivcol, Work->pivrow)) ;
- DEBUG2 (("do_extend: "ID"\n", Work->do_extend)) ;
- DEBUG2 (("do_update: "ID"\n", Work->do_update)) ;
- DEBUG2 (("do_grow: "ID"\n", Work->do_grow)) ;
+ DEBUG2 (("do_extend: " ID "\n", Work->do_extend)) ;
+ DEBUG2 (("do_update: " ID "\n", Work->do_update)) ;
+ DEBUG2 (("do_grow: " ID "\n", Work->do_grow)) ;
/* ---------------------------------------------------------------------- */
/* keep track of the diagonal */
DEBUG4 (("Lsolve start:\n")) ;
for (j = 0 ; j < Numeric->n_row ; j++)
{
- DEBUG4 (("Lsolve start "ID": ", j)) ;
+ DEBUG4 (("Lsolve start " ID ": ", j)) ;
EDEBUG4 (X [j]) ;
DEBUG4 (("\n")) ;
}
for (k = 0 ; k < n1 ; k++)
{
- DEBUG4 (("Singleton k "ID"\n", k)) ;
+ DEBUG4 (("Singleton k " ID "\n", k)) ;
xk = X [k] ;
deg = Lilen [k] ;
if (deg > 0 && IS_NONZERO (xk))
Lval = (Entry *) (Numeric->Memory + lp) ;
for (j = 0 ; j < deg ; j++)
{
- DEBUG4 ((" row "ID" k "ID" value", Li [j], k)) ;
+ DEBUG4 ((" row " ID " k " ID " value", Li [j], k)) ;
EDEBUG4 (Lval [j]) ;
DEBUG4 (("\n")) ;
/* X [Li [j]] -= xk * Lval [j] ; */
pos = Lpos [k] ;
if (pos != EMPTY)
{
- DEBUG4 ((" k "ID" removing row "ID" at position "ID"\n",
+ DEBUG4 ((" k " ID " removing row " ID " at position " ID "\n",
k, Pattern [pos], pos)) ;
ASSERT (!newLchain) ;
ASSERT (deg > 0) ;
for (j = 0 ; j < llen ; j++)
{
row = *ip++ ;
- DEBUG4 ((" row "ID" k "ID"\n", row, k)) ;
+ DEBUG4 ((" row " ID " k " ID "\n", row, k)) ;
ASSERT (row > k) ;
Pattern [deg++] = row ;
}
xp = (Entry *) (Numeric->Memory + lp + UNITS (Int, llen)) ;
for (j = 0 ; j < deg ; j++)
{
- DEBUG4 ((" row "ID" k "ID" value", Pattern [j], k)) ;
+ DEBUG4 ((" row " ID " k " ID " value", Pattern [j], k)) ;
EDEBUG4 (*xp) ;
DEBUG4 (("\n")) ;
/* X [Pattern [j]] -= xk * (*xp) ; */
#ifndef NDEBUG
for (j = 0 ; j < Numeric->n_row ; j++)
{
- DEBUG4 (("Lsolve done "ID": ", j)) ;
+ DEBUG4 (("Lsolve done " ID ": ", j)) ;
EDEBUG4 (X [j]) ;
DEBUG4 (("\n")) ;
}
DEBUG4 (("Ltsolve start:\n")) ;
for (j = 0 ; j < Numeric->n_row ; j++)
{
- DEBUG4 (("Ltsolve start "ID": ", j)) ;
+ DEBUG4 (("Ltsolve start " ID ": ", j)) ;
EDEBUG4 (X [j]) ;
DEBUG4 (("\n")) ;
}
pos = Lpos [k] ;
if (pos != EMPTY)
{
- DEBUG4 ((" k "ID" removing row "ID" at position "ID"\n",
+ DEBUG4 ((" k " ID " removing row " ID " at position " ID "\n",
k, Pattern [pos], pos)) ;
ASSERT (k != kstart) ;
ASSERT (deg > 0) ;
for (j = 0 ; j < llen ; j++)
{
row = *ip++ ;
- DEBUG4 ((" row "ID" k "ID"\n", row, k)) ;
+ DEBUG4 ((" row " ID " k " ID "\n", row, k)) ;
ASSERT (row > k) ;
Pattern [deg++] = row ;
}
xk = X [k] ;
for (j = 0 ; j < deg ; j++)
{
- DEBUG4 ((" row "ID" k "ID" value", Pattern [j], k)) ;
+ DEBUG4 ((" row " ID " k " ID " value", Pattern [j], k)) ;
EDEBUG4 (*xp) ;
DEBUG4 (("\n")) ;
pos = Lpos [k] ;
if (pos != EMPTY)
{
- DEBUG4 ((" k "ID" adding row "ID" at position "ID"\n",
+ DEBUG4 ((" k " ID " adding row " ID " at position " ID "\n",
k, k, pos)) ;
ASSERT (k != kstart) ;
ASSERT (pos >= 0 && pos <= deg) ;
for (k = n1 - 1 ; k >= 0 ; k--)
{
- DEBUG4 (("Singleton k "ID"\n", k)) ;
+ DEBUG4 (("Singleton k " ID "\n", k)) ;
deg = Lilen [k] ;
if (deg > 0)
{
Lval = (Entry *) (Numeric->Memory + lp) ;
for (j = 0 ; j < deg ; j++)
{
- DEBUG4 ((" row "ID" k "ID" value", Li [j], k)) ;
+ DEBUG4 ((" row " ID " k " ID " value", Li [j], k)) ;
EDEBUG4 (Lval [j]) ;
DEBUG4 (("\n")) ;
#ifdef CONJUGATE_SOLVE
#ifndef NDEBUG
for (j = 0 ; j < Numeric->n_row ; j++)
{
- DEBUG4 (("Ltsolve done "ID": ", j)) ;
+ DEBUG4 (("Ltsolve done " ID ": ", j)) ;
EDEBUG4 (X [j]) ;
DEBUG4 (("\n")) ;
}
/* see AMD/Source/amd_global.c for the memory allocator selection */
p = amd_malloc (size) ;
- DEBUG0 ((ID"\n", (Int) p)) ;
+ DEBUG0 ((ID "\n", (Int) p)) ;
#if defined (UMF_MALLOC_COUNT) || !defined (NDEBUG)
if (p)
/* One more object has been malloc'ed. Keep track of the count. */
/* (purely for sanity checks). */
UMF_malloc_count++ ;
- DEBUG0 ((" successful, new malloc count: "ID"\n", UMF_malloc_count)) ;
+ DEBUG0 ((" successful, new malloc count: " ID "\n", UMF_malloc_count)) ;
}
#endif
ep = (Element *) p ;
- DEBUG2 (("alloc_element done ("ID" x "ID"): p: "ID" i "ID"\n",
+ DEBUG2 (("alloc_element done (" ID " x " ID "): p: " ID " i " ID "\n",
nrows, ncols, (Int) (p-Numeric->Memory), i)) ;
/* Element data structure, in order: */
ep->rdeg = 0 ;
ep->next = EMPTY ;
- DEBUG2 (("new block size: "ID" ", GET_BLOCK_SIZE (Numeric->Memory + i))) ;
- DEBUG2 (("Element size needed "ID"\n", GET_ELEMENT_SIZE (nrows, ncols))) ;
+ DEBUG2 (("new block size: " ID " ", GET_BLOCK_SIZE (Numeric->Memory + i))) ;
+ DEBUG2 (("Element size needed " ID "\n", GET_ELEMENT_SIZE (nrows, ncols))) ;
*epout = ep ;
)
{
Int p, usage ;
- DEBUG2 (("GET BLOCK: from head, size "ID" ", nunits)) ;
+ DEBUG2 (("GET BLOCK: from head, size " ID " ", nunits)) ;
ASSERT (Numeric != (NumericType *) NULL) ;
ASSERT (Numeric->Memory != (Unit *) NULL) ;
p = Numeric->ihead ;
Numeric->ihead += nunits ;
- DEBUG2 (("p: "ID"\n", p)) ;
+ DEBUG2 (("p: " ID "\n", p)) ;
usage = Numeric->ihead + Numeric->tail_usage ;
Numeric->max_usage = MAX (Numeric->max_usage, usage) ;
return (p) ;
UMF_allocfail = FALSE ; /* don't fail the next time */
return (0) ;
}
- DEBUG2 (("UMF_mem_alloc_tail_block, size: "ID" + 1 = "ID": ",
+ DEBUG2 (("UMF_mem_alloc_tail_block, size: " ID " + 1 = " ID ": ",
nunits, nunits+1)) ;
#endif
/* internal fragmentation would be too small */
/* allocate the entire free block */
p->header.size = -p->header.size ;
- DEBUG2 (("GET BLOCK: p: "ID" size: "ID", all of big: "ID" size: "
- ID"\n", (Int) (p-Numeric->Memory), nunits, Numeric->ibig,
+ DEBUG2 (("GET BLOCK: p: " ID " size: " ID ", all of big: " ID " size: "
+ ID "\n", (Int) (p-Numeric->Memory), nunits, Numeric->ibig,
p->header.size)) ;
/* no more biggest block */
Numeric->ibig = EMPTY ;
pbig->header.size = -bigsize ;
pbig->header.prevsize = nunits ;
pnext->header.prevsize = bigsize ;
- DEBUG2 (("GET BLOCK: p: "ID" size: "ID", some of big: "ID" left: "
- ID"\n", (Int) (p-Numeric->Memory), nunits, Numeric->ibig,
+ DEBUG2 (("GET BLOCK: p: " ID " size: " ID ", some of big: " ID " left: "
+ ID "\n", (Int) (p-Numeric->Memory), nunits, Numeric->ibig,
bigsize)) ;
}
p->header.size = nunits ;
p->header.prevsize = 0 ;
pnext->header.prevsize = nunits ;
- DEBUG2 (("p: "ID" size: "ID", new tail "ID"\n",
+ DEBUG2 (("p: " ID " size: " ID ", new tail " ID "\n",
(Int) (p-Numeric->Memory), nunits, Numeric->itail)) ;
}
p = Numeric->Memory + i ;
p-- ; /* get the corresponding header */
- DEBUG2 (("free block: p: "ID, (Int) (p-Numeric->Memory))) ;
+ DEBUG2 (("free block: p: " ID, (Int) (p-Numeric->Memory))) ;
ASSERT (p >= Numeric->Memory + Numeric->itail) ;
ASSERT (p < Numeric->Memory + Numeric->size) ;
ASSERT (p->header.size > 0) ; /* block not already free */
/* ---------------------------------------------------------------------- */
pnext = p + 1 + p->header.size ;
- DEBUG2 (("size: "ID" next: "ID" ", p->header.size,
+ DEBUG2 (("size: " ID " next: " ID " ", p->header.size,
(Int) (pnext-Numeric->Memory))) ;
ASSERT (pnext < Numeric->Memory + Numeric->size) ;
ASSERT (pnext->header.prevsize == p->header.size) ;
{
ASSERT (p->header.prevsize > 0) ;
pprev = p - 1 - p->header.prevsize ;
- DEBUG2 ((" prev: "ID" ", (Int) (pprev-Numeric->Memory))) ;
+ DEBUG2 ((" prev: " ID " ", (Int) (pprev-Numeric->Memory))) ;
ASSERT (pprev >= Numeric->Memory + Numeric->itail) ;
sprev = pprev->header.size ;
if (sprev < 0)
/* top block in list is freed */
Numeric->itail = pnext - Numeric->Memory ;
pnext->header.prevsize = 0 ;
- DEBUG2 ((" NEW TAIL : "ID" ", Numeric->itail)) ;
+ DEBUG2 ((" NEW TAIL : " ID " ", Numeric->itail)) ;
ASSERT (pnext->header.size > 0) ;
if (Numeric->ibig != EMPTY && Numeric->ibig <= Numeric->itail)
{
p->header.size = -(p->header.size) ;
}
- DEBUG2 (("new p: "ID" freesize: "ID"\n", (Int) (p-Numeric->Memory),
+ DEBUG2 (("new p: " ID " freesize: " ID "\n", (Int) (p-Numeric->Memory),
-(p->header.size))) ;
}
ASSERT (Numeric != (NumericType *) NULL) ;
ASSERT (Numeric->Memory != (Unit *) NULL) ;
ASSERT (Numeric->size >= 3) ;
- DEBUG0 (("Init memory space, size "ID"\n", Numeric->size)) ;
+ DEBUG0 (("Init memory space, size " ID "\n", Numeric->size)) ;
Numeric->ngarbage = 0 ;
Numeric->nrealloc = 0 ;
/* allocate the 2-unit tail marker block and initialize it */
Numeric->itail -= 2 ;
p = Numeric->Memory + Numeric->itail ;
- DEBUG2 (("p "ID" tail "ID"\n", (Int) (p-Numeric->Memory), Numeric->itail)) ;
+ DEBUG2 (("p " ID " tail " ID "\n", (Int) (p-Numeric->Memory), Numeric->itail)) ;
Numeric->tail_usage = 2 ;
p->header.prevsize = 0 ;
p->header.size = 1 ;
}
size *= size_of_object ;
- DEBUG0 (("UMF_realloc: "ID" n_objects "ID" size_of_object "ID"\n",
+ DEBUG0 (("UMF_realloc: " ID " n_objects " ID " size_of_object " ID "\n",
(Int) p, n_objects, (Int) size_of_object)) ;
/* see AMD/Source/amd_global.c for the memory allocator selection */
}
#endif
- DEBUG0 (("UMF_realloc: "ID" new malloc count "ID"\n",
+ DEBUG0 (("UMF_realloc: " ID " new malloc count " ID "\n",
(Int) p2, UMF_malloc_count)) ;
return (p2) ;
ASSERT (prl >= 3) ;
- PRINTF4U (("permutation vector, n = "ID". ", n)) ;
+ PRINTF4U (("permutation vector, n = " ID ". ", n)) ;
if (n <= 0)
{
for (k = 0 ; k < n ; k++)
{
i = P [k] ;
- PRINTF4 ((" "ID" : "ID" ", INDEX (k), INDEX (i))) ;
+ PRINTF4 ((" " ID " : " ID " ", INDEX (k), INDEX (i))) ;
valid = (i >= 0 && i < n) ;
if (valid)
{
Entry xi ;
/* if Xz is null, then X is in "merged" format (compatible with Entry, */
/* and ANSI C99 double _Complex type). */
- PRINTF ((" "ID" :", INDEX (i))) ;
+ PRINTF ((" " ID " :", INDEX (i))) ;
if (scalar)
{
PRINT_SCALAR (Xx [i]) ;
if (user || prl >= 4)
{
- PRINTF (("dense vector, n = "ID". ", n)) ;
+ PRINTF (("dense vector, n = " ID ". ", n)) ;
}
if (user)
for (i = 0 ; i < cdeg1 ; i++)
{
row = Pattern [i] ;
- DEBUG4 ((" row: "ID"\n", row)) ;
+ DEBUG4 ((" row: " ID "\n", row)) ;
ASSERT (row >= 0 && row < Numeric->n_row) ;
ASSERT (i == Pos [row]) ;
}
}
else
{
- DEBUG4 ((" row: "ID" pos "ID"\n", row, Pos [row])) ;
+ DEBUG4 ((" row: " ID " pos " ID "\n", row, Pos [row])) ;
}
}
ASSERT (cnt == Numeric->n_row) ;
if (SCALAR_IS_NONZERO (a) && a >= toler2)
{
/* found it! */
- DEBUG3 (("Symmetric pivot: "ID" "ID"\n", pivcol, diag_row));
+ DEBUG3 (("Symmetric pivot: " ID " " ID "\n", pivcol, diag_row));
found = TRUE ;
if (Frpos [diag_row] >= 0 && Frpos [diag_row] < fnrows)
{
row = Pattern [i] ;
deg = Row_degree [row] ;
#ifndef NDEBUG
- DEBUG6 ((ID" candidate row "ID" deg "ID" absval %g\n",
+ DEBUG6 ((ID " candidate row " ID " deg " ID " absval %g\n",
i, row, deg, a)) ;
UMF_dump_rowcol (0, Numeric, Work, row, TRUE) ;
#endif
row = Pattern [i] ;
deg = Row_degree [row] ;
#ifndef NDEBUG
- DEBUG6 ((ID" candidate row "ID" deg "ID" absval %g\n",
+ DEBUG6 ((ID " candidate row " ID " deg " ID " absval %g\n",
i, row, deg, a)) ;
UMF_dump_rowcol (0, Numeric, Work, row, TRUE) ;
#endif
row = Pattern [i] ;
deg = Row_degree [row] ;
#ifndef NDEBUG
- DEBUG6 ((ID" candidate row "ID" deg "ID" absval %g\n",
+ DEBUG6 ((ID " candidate row " ID " deg " ID " absval %g\n",
i, row, deg, a)) ;
UMF_dump_rowcol (0, Numeric, Work, row, TRUE) ;
#endif
*/
pivrow [IN] = Work->Frows [0] ;
- DEBUGm4 (("Got zero pivrow[OUT][IN] "ID" from current front\n",
+ DEBUGm4 (("Got zero pivrow[OUT][IN] " ID " from current front\n",
pivrow [IN])) ;
}
else
n_row = Numeric->n_row ;
frontid = Work->frontid ;
- DEBUGm4 (("Note: pivcol: "ID" is empty front "ID"\n",
+ DEBUGm4 (("Note: pivcol: " ID " is empty front " ID "\n",
pivcol, frontid)) ;
#ifndef NDEBUG
DEBUG1 (("Calling dump rowmerge\n")) ;
fleftmost = Front_leftmostdesc [frontid] ;
row1 = Front_new1strow [fleftmost] ;
row2 = Front_1strow [frontid+1] - 1 ;
- DEBUG1 (("Leftmost: "ID" Rows ["ID" to "ID"] srch ["ID" to "ID"]\n",
+ DEBUG1 (("Leftmost: " ID " Rows [" ID " to " ID "] srch [" ID " to " ID "]\n",
fleftmost, Front_1strow [frontid], row2, row1, row2)) ;
/* look in the range row1 ... row2 */
for (row = row1 ; row <= row2 ; row++)
{
- DEBUG3 ((" Row: "ID"\n", row)) ;
+ DEBUG3 ((" Row: " ID "\n", row)) ;
if (NON_PIVOTAL_ROW (row))
{
/* found it */
- DEBUG3 ((" Row: "ID" found\n", row)) ;
+ DEBUG3 ((" Row: " ID " found\n", row)) ;
ASSERT (Frpos [row] == EMPTY) ;
pivrow [OUT] = row ;
DEBUGm4 (("got row merge pivrow %d\n", pivrow [OUT])) ;
/* not found, look in empty row set in "dummy" front */
row1 = Front_new1strow [nfr] ;
row2 = n_row-1 ;
- DEBUG3 (("Empty: "ID" Rows ["ID" to "ID"] srch["ID" to "ID"]\n",
+ DEBUG3 (("Empty: " ID " Rows [" ID " to " ID "] srch[" ID " to " ID "]\n",
nfr, Front_1strow [nfr], row2, row1, row2)) ;
/* look in the range row1 ... row2 */
for (row = row1 ; row <= row2 ; row++)
{
- DEBUG3 ((" Empty Row: "ID"\n", row)) ;
+ DEBUG3 ((" Empty Row: " ID "\n", row)) ;
if (NON_PIVOTAL_ROW (row))
{
/* found it */
- DEBUG3 ((" Empty Row: "ID" found\n", row)) ;
+ DEBUG3 ((" Empty Row: " ID " found\n", row)) ;
ASSERT (Frpos [row] == EMPTY) ;
pivrow [OUT] = row ;
DEBUGm4 (("got dummy row pivrow %d\n", pivrow [OUT])) ;
#endif
#ifndef NDEBUG
- DEBUG4 (("pivrow [IN]: "ID"\n", pivrow [IN])) ;
+ DEBUG4 (("pivrow [IN]: " ID "\n", pivrow [IN])) ;
UMF_dump_rowcol (0, Numeric, Work, pivrow [IN], TRUE) ;
#endif
#ifndef NDEBUG
/* check Fcols */
- DEBUG5 (("ROW ASSEMBLE: rdeg "ID"\nREDUCE ROW "ID"\n",
+ DEBUG5 (("ROW ASSEMBLE: rdeg " ID "\nREDUCE ROW " ID "\n",
fncols, pivrow [IN])) ;
for (j = 0 ; j < fncols ; j++)
{
DEBUG4 (("Reduced IN row:\n")) ;
for (j = 0 ; j < fncols ; j++)
{
- DEBUG6 ((" "ID" "ID" "ID"\n",
+ DEBUG6 ((" " ID " " ID " " ID "\n",
j, Work->Fcols [j], Fcpos [Work->Fcols [j]])) ;
ASSERT (Fcpos [Work->Fcols [j]] >= 0) ;
}
for (j = fncols ; j < rdeg [IN] ; j++)
{
- DEBUG6 ((" "ID" "ID" "ID"\n", j, W_i [j], Wrp [W_i [j]]));
+ DEBUG6 ((" " ID " " ID " " ID "\n", j, W_i [j], Wrp [W_i [j]]));
ASSERT (W_i [j] >= 0 && W_i [j] < Work->n_col) ;
ASSERT (Wrp [W_i [j]] == Wrpflag) ;
}
/* ---------------------------------------------------------------------- */
#ifndef NDEBUG
- DEBUG4 (("pivrow [OUT]: "ID"\n", pivrow [OUT])) ;
+ DEBUG4 (("pivrow [OUT]: " ID "\n", pivrow [OUT])) ;
UMF_dump_rowcol (0, Numeric, Work, pivrow [OUT], TRUE) ;
#endif
DEBUG4 (("Reduced row OUT:\n")) ;
for (j = 0 ; j < rdeg [OUT] ; j++)
{
- DEBUG6 ((" "ID" "ID" "ID"\n", j, W_o [j], Wrp [W_o [j]])) ;
+ DEBUG6 ((" " ID " " ID " " ID "\n", j, W_o [j], Wrp [W_o [j]])) ;
ASSERT (W_o [j] >= 0 && W_o [j] < Work->n_col) ;
ASSERT (Wrp [W_o [j]] == Wrpflag) ;
}
#ifndef NDEBUG
ASSERT (fnrows == Work->fnrows_new + 1) ;
ASSERT (fncols == Work->fncols_new + 1) ;
- DEBUG1 (("SCALE COL: fnrows "ID" fncols "ID"\n", fnrows, fncols)) ;
+ 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 " 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: ")) ;
Int fs = fspos / fnr_curr ;
DEBUG6 (("Shift pivot column in front\n")) ;
- DEBUG6 (("fspos: "ID" flpos: "ID"\n", fspos, fncols * fnr_curr)) ;
+ DEBUG6 (("fspos: " ID " flpos: " ID "\n", fspos, fncols * fnr_curr)) ;
/* ------------------------------------------------------------------ */
/* move Fe => Fs */
#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 " 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")) ;
fnrows = --(Work->fnrows) ;
DEBUG6 (("Swap/shift pivot row in front:\n")) ;
- DEBUG6 (("fspos: "ID" flpos: "ID"\n", fspos, fnrows)) ;
+ DEBUG6 (("fspos: " ID " flpos: " ID "\n", fspos, fnrows)) ;
if (fspos == fnrows)
{
#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",
+ "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")) ;
Row_tuples [pivrow] = 0 ;
Col_tuples [pivcol] = 0 ;
- DEBUG5 (("number of pivots prior to this one: "ID"\n", k)) ;
+ DEBUG5 (("number of pivots prior to this one: " ID "\n", k)) ;
ASSERT (NON_PIVOTAL_ROW (pivrow)) ;
ASSERT (NON_PIVOTAL_COL (pivcol)) ;
)
{
Int i, next, cnt ;
- DEBUG6 (("%s Singleton list: head "ID" tail "ID"\n", name, head, tail)) ;
+ DEBUG6 (("%s Singleton list: head " ID " tail " ID "\n", name, head, tail)) ;
i = head ;
ASSERT (head >= EMPTY && head < n) ;
ASSERT (tail >= EMPTY && tail < n) ;
cnt = 0 ;
while (i != EMPTY)
{
- DEBUG7 ((" "ID": "ID" deg: "ID"\n", cnt, i, Deg [i])) ;
+ DEBUG7 ((" " ID ": " ID " deg: " ID "\n", cnt, i, Deg [i])) ;
ASSERT (i >= 0 && i < n) ;
next = Next [i] ;
if (i == tail) ASSERT (next == EMPTY) ;
p1 = Xp [x] ;
p2 = Xp [x+1] ;
xdeg = Xdeg [x] ;
- DEBUG6 (("Dump %s "ID" p1 "ID" p2 "ID" deg "ID"\n",
+ DEBUG6 (("Dump %s " ID " p1 " ID " p2 " ID " deg " ID "\n",
xname, x, p1, p2, xdeg)) ;
do_xdeg = (xdeg >= 0) ;
for (p = p1 ; p < p2 ; p++)
{
y = Xi [p] ;
- DEBUG7 ((" %s "ID" deg: ", yname, y)) ;
+ DEBUG7 ((" %s " ID " deg: ", yname, y)) ;
ASSERT (y >= 0 && y < ny) ;
ydeg = Ydeg [y] ;
- DEBUG7 ((ID"\n", ydeg)) ;
+ DEBUG7 ((ID "\n", ydeg)) ;
if (do_xdeg && ydeg >= 0)
{
xdeg-- ;
{
/* remove the singleton at the head of the queue */
xpivot = head ;
- DEBUG1 (("------ Order %s singleton: "ID"\n", xname, xpivot)) ;
+ DEBUG1 (("------ Order %s singleton: " ID "\n", xname, xpivot)) ;
head = Next [xpivot] ;
if (head == EMPTY) tail = EMPTY ;
for (p = Xp [xpivot] ; p < p2 ; p++)
{
y = Xi [p] ;
- DEBUG1 (("%s: "ID"\n", yname, y)) ;
+ DEBUG1 (("%s: " ID "\n", yname, y)) ;
if (Ydeg [y] >= 0)
{
/* this is a live index in this xpivot vector */
for (p = Xp [xpivot] ; p < p2 ; p++)
{
y = Xi [p] ;
- DEBUG1 (("%s: "ID"\n", yname, y)) ;
+ DEBUG1 (("%s: " ID "\n", yname, y)) ;
if (Ydeg [y] >= 0)
{
/* this is a live index in this xpivot vector */
}
}
- DEBUG1 (("Pivot %s: "ID"\n", yname, ypivot)) ;
+ DEBUG1 (("Pivot %s: " ID "\n", yname, ypivot)) ;
ASSERT (ypivot != EMPTY) ;
- DEBUG1 (("deg "ID"\n", Ydeg [ypivot])) ;
+ DEBUG1 (("deg " ID "\n", Ydeg [ypivot])) ;
ASSERT (Ydeg [ypivot] >= 0) ;
/* decrement the degrees after removing this singleton */
- DEBUG1 (("p1 "ID"\n", Yp [ypivot])) ;
- DEBUG1 (("p2 "ID"\n", Yp [ypivot+1])) ;
+ DEBUG1 (("p1 " ID "\n", Yp [ypivot])) ;
+ DEBUG1 (("p2 " ID "\n", Yp [ypivot+1])) ;
p2 = Yp [ypivot+1] ;
for (p = Yp [ypivot] ; p < p2 ; p++)
{
x = Yi [p] ;
- DEBUG1 ((" %s: "ID" deg: "ID"\n", xname, x, Xdeg [x])) ;
+ DEBUG1 ((" %s: " ID " deg: " ID "\n", xname, x, Xdeg [x])) ;
if (Xdeg [x] < 0) continue ;
ASSERT (Xdeg [x] > 0) ;
if (x == xpivot) continue ;
Next [tail] = x ;
}
tail = x ;
- DEBUG1 ((" New %s singleton: "ID"\n", xname, x)) ;
+ DEBUG1 ((" New %s singleton: " ID "\n", xname, x)) ;
#ifndef NDEBUG
if (k % 100 == 0)
{
}
#ifndef NDEBUG
- DEBUGm4 (("%s singletons: k = "ID"\n", xname, k)) ;
+ DEBUGm4 (("%s singletons: k = " ID "\n", xname, k)) ;
for (i = k1 ; i < k ; i++)
{
- DEBUG1 ((" %s: "ID" %s: "ID"\n", xname, Xperm [i], yname, Yperm [i])) ;
+ DEBUG1 ((" %s: " ID " %s: " ID "\n", xname, Xperm [i], yname, Yperm [i])) ;
}
ASSERT (k > 0) ;
#endif
if (head == EMPTY) tail = col ;
Next [col] = head ;
head = col ;
- DEBUG1 (("Column singleton: "ID"\n", col)) ;
+ DEBUG1 (("Column singleton: " ID "\n", col)) ;
}
}
if (head == EMPTY) tail = row ;
Next [row] = head ;
head = row ;
- DEBUG1 (("Row singleton: "ID"\n", row)) ;
+ DEBUG1 (("Row singleton: " ID "\n", row)) ;
}
}
n1r = n1 - n1c ;
}
- DEBUG0 (("n1 "ID"\n", n1)) ;
+ DEBUG0 (("n1 " ID "\n", n1)) ;
*p_n1r = n1r ;
*p_n1c = n1c ;
return (n1) ;
/* find singletons in the user column permutation, Quser */
pivcol = Quser [0] ;
found = (Cdeg [pivcol] == 1) ;
- DEBUG0 (("Is first col: "ID" a col singleton?: "ID"\n", pivcol, found)) ;
+ DEBUG0 (("Is first col: " ID " a col singleton?: " ID "\n", pivcol, found)) ;
if (!found)
{
/* the first column is not a column singleton, check for a row
{
if (Rdeg [Ai [p]] == 1)
{
- DEBUG0 (("Row singleton in first col: "ID" row: "ID"\n",
+ DEBUG0 (("Row singleton in first col: " ID " row: " ID "\n",
pivcol, Ai [p])) ;
found = TRUE ;
break ;
/* pivcol is a column singleton */
/* -------------------------------------------------------------- */
- DEBUG0 (("Found a col singleton: k "ID" pivcol "ID"\n", k, pivcol));
+ DEBUG0 (("Found a col singleton: k " ID " pivcol " ID "\n", k, pivcol));
/* find the pivrow to match with this pivcol */
#ifndef NDEBUG
for (p = Ap [pivcol] ; p < p2 ; p++)
{
row = Ai [p] ;
- DEBUG1 (("row: "ID"\n", row)) ;
+ DEBUG1 (("row: " ID "\n", row)) ;
if (Rdeg [row] >= 0)
{
/* this is a live index in this column vector */
for (p = Ap [pivcol] ; p < p2 ; p++)
{
row = Ai [p] ;
- DEBUG1 (("row: "ID"\n", row)) ;
+ DEBUG1 (("row: " ID "\n", row)) ;
if (Rdeg [row] >= 0)
{
/* this is a live index in this pivcol vector */
}
}
- DEBUG1 (("Pivot row: "ID"\n", pivrow)) ;
+ DEBUG1 (("Pivot row: " ID "\n", pivrow)) ;
ASSERT (pivrow != EMPTY) ;
- DEBUG1 (("deg "ID"\n", Rdeg [pivrow])) ;
+ DEBUG1 (("deg " ID "\n", Rdeg [pivrow])) ;
ASSERT (Rdeg [pivrow] >= 0) ;
/* decrement the degrees after removing this col singleton */
- DEBUG1 (("p1 "ID"\n", Rp [pivrow])) ;
- DEBUG1 (("p2 "ID"\n", Rp [pivrow+1])) ;
+ DEBUG1 (("p1 " ID "\n", Rp [pivrow])) ;
+ DEBUG1 (("p2 " ID "\n", Rp [pivrow+1])) ;
p2 = Rp [pivrow+1] ;
for (p = Rp [pivrow] ; p < p2 ; p++)
{
col = Ri [p] ;
- DEBUG1 ((" col: "ID" deg: "ID"\n", col, Cdeg [col])) ;
+ DEBUG1 ((" col: " ID " deg: " ID "\n", col, Cdeg [col])) ;
if (Cdeg [col] < 0) continue ;
ASSERT (Cdeg [col] > 0) ;
Cdeg [col]-- ;
pivrow = Ai [p] ;
if (Rdeg [pivrow] == 1)
{
- DEBUG0 (("Row singleton in pivcol: "ID" row: "ID"\n",
+ DEBUG0 (("Row singleton in pivcol: " ID " row: " ID "\n",
pivcol, pivrow)) ;
found = TRUE ;
break ;
for (p = Rp [pivrow] ; p < p2 ; p++)
{
col = Ri [p] ;
- DEBUG1 (("col: "ID" cdeg::: "ID"\n", col, Cdeg [col])) ;
+ DEBUG1 (("col: " ID " cdeg::: " ID "\n", col, Cdeg [col])) ;
if (Cdeg [col] >= 0)
{
/* this is a live index in this column vector */
}
#endif
- DEBUG1 (("Pivot row: "ID"\n", pivrow)) ;
- DEBUG1 (("pivcol deg "ID"\n", Cdeg [pivcol])) ;
+ DEBUG1 (("Pivot row: " ID "\n", pivrow)) ;
+ DEBUG1 (("pivcol deg " ID "\n", Cdeg [pivcol])) ;
ASSERT (Cdeg [pivcol] > 1) ;
/* decrement the degrees after removing this row singleton */
- DEBUG1 (("p1 "ID"\n", Ap [pivcol])) ;
- DEBUG1 (("p2 "ID"\n", Ap [pivcol+1])) ;
+ DEBUG1 (("p1 " ID "\n", Ap [pivcol])) ;
+ DEBUG1 (("p2 " ID "\n", Ap [pivcol+1])) ;
p2 = Ap [pivcol+1] ;
for (p = Ap [pivcol] ; p < p2 ; p++)
{
row = Ai [p] ;
- DEBUG1 ((" row: "ID" deg: "ID"\n", row, Rdeg [row])) ;
+ DEBUG1 ((" row: " ID " deg: " ID "\n", row, Rdeg [row])) ;
if (Rdeg [row] < 0) continue ;
ASSERT (Rdeg [row] > 0) ;
Rdeg [row]-- ;
}
- DEBUGm4 (("User singletons found: "ID"\n", n1)) ;
+ DEBUGm4 (("User singletons found: " ID "\n", n1)) ;
ASSERT (n1 > 0) ;
*p_n1r = n1r ;
nempty = 0 ;
s = n1 ;
max_deg = 0 ;
- DEBUG0 (("n1 "ID" nempty "ID"\n", n1, nempty)) ;
+ DEBUG0 (("n1 " ID " nempty " ID "\n", n1, nempty)) ;
for (k = 0 ; k < nx ; k++)
{
x = (Xuser != (Int *) NULL) ? Xuser [k] : k ;
- DEBUG0 (("finish perm k "ID" x "ID" nx "ID"\n", k, x, nx)) ;
+ DEBUG0 (("finish perm k " ID " x " ID " nx " ID "\n", k, x, nx)) ;
deg = Xdeg [x] ;
if (deg == 0)
{
/* this row/col is empty in the pruned submatrix */
ASSERT (s < nx - nempty) ;
- DEBUG0 (("empty k "ID"\n", k)) ;
+ DEBUG0 (("empty k " ID "\n", k)) ;
nempty++ ;
Xperm [nx - nempty] = x ;
}
{
is_sym = FALSE ;
}
- DEBUGm4 (("Submatrix square and symmetrically permuted? "ID"\n", is_sym)) ;
- DEBUGm4 (("singletons "ID" row "ID" col "ID"\n", n1, n1r, n1c)) ;
- DEBUGm4 (("Empty cols "ID" rows "ID"\n", nempty_col, nempty_row)) ;
+ DEBUGm4 (("Submatrix square and symmetrically permuted? " ID "\n", is_sym)) ;
+ DEBUGm4 (("singletons " ID " row " ID " col " ID "\n", n1, n1r, n1c)) ;
+ DEBUGm4 (("Empty cols " ID " rows " ID "\n", nempty_col, nempty_row)) ;
*p_n1 = n1 ;
*p_n1r = n1r ;
*p_n1c = n1c ;
fnrows_max = Symbolic->Chain_maxrows [chain] ;
fncols_max = Symbolic->Chain_maxcols [chain] ;
- DEBUGm2 (("Start Front for chain "ID". fnrows_max "ID" fncols_max "ID"\n",
+ DEBUGm2 (("Start Front for chain " ID ". fnrows_max " ID " fncols_max " ID "\n",
chain, fnrows_max, fncols_max)) ;
Work->fnrows_max = fnrows_max ;
tp = (Tuple *) Memory + tpi ;
tpend = tp + Col_tlen [col] ;
cdeg = 0 ;
- DEBUGm3 (("\n=============== start front: col "ID" tlen "ID"\n",
+ DEBUGm3 (("\n=============== start front: col " ID " tlen " ID "\n",
col, Col_tlen [col])) ;
for ( ; tp < tpend ; tp++)
{
- DEBUG1 (("Tuple ("ID","ID")\n", tp->e, tp->f)) ;
+ DEBUG1 (("Tuple (" ID "," ID ")\n", tp->e, tp->f)) ;
e = tp->e ;
if (!E [e]) continue ;
f = tp->f ;
p += UNITS (Element, 1) ;
Cols = (Int *) p ;
if (Cols [f] == EMPTY) continue ;
- DEBUG1 ((" nrowsleft "ID"\n", ep->nrowsleft)) ;
+ DEBUG1 ((" nrowsleft " ID "\n", ep->nrowsleft)) ;
cdeg += ep->nrowsleft ;
}
#ifndef NDEBUG
- DEBUGm3 (("start front cdeg: "ID" col "ID"\n", cdeg, col)) ;
+ DEBUGm3 (("start front cdeg: " ID " col " ID "\n", cdeg, col)) ;
UMF_dump_rowcol (1, Numeric, Work, col, FALSE) ;
#endif
cdeg = 0 ;
}
- DEBUGm2 (("fnrows max "ID" fncols_max "ID"\n", fnrows_max, fncols_max)) ;
+ DEBUGm2 (("fnrows max " ID " fncols_max " ID "\n", fnrows_max, fncols_max)) ;
/* the current frontal matrix is empty */
ASSERT (Work->fnrows == 0 && Work->fncols == 0 && Work->fnpiv == 0) ;
Work->fncols_new = 0 ;
/* desired size is fnr2-by-fnc2 (includes L and U blocks): */
- DEBUGm2 ((" fsize "ID" fcurr_size "ID"\n", fsize, fcurr_size)) ;
- DEBUGm2 ((" maxfrsize "ID" fnr_curr "ID" fnc_curr "ID"\n", maxfrsize,
+ DEBUGm2 ((" fsize " ID " fcurr_size " ID "\n", fsize, fcurr_size)) ;
+ DEBUGm2 ((" maxfrsize " ID " fnr_curr " ID " fnc_curr " ID "\n", maxfrsize,
Work->fnr_curr, Work->fnc_curr)) ;
if (fsize >= maxfrsize && !overflow)
fnr2 = fnrows_max + nb ;
fnc2 = fncols_max + nb ;
fsize = maxfrsize ;
- DEBUGm1 ((" sufficient for ("ID"+"ID")-by-("ID"+"ID")\n",
+ DEBUGm1 ((" sufficient for (" ID "+" ID ")-by-(" ID "+" ID ")\n",
fnrows_max, nb, fncols_max, nb)) ;
}
else
fnc2 = fsize / fnr2 ;
}
}
- DEBUGm1 ((" smaller "ID"-by-"ID"\n", fnr2, fnc2)) ;
+ DEBUGm1 ((" smaller " ID "-by-" ID "\n", fnr2, fnc2)) ;
}
fnr2 = MIN (fnr2, fnrows_max + nb) ;
fnc2 = MIN (fnc2, fncols_max + nb) ;
nb = Work->nb ;
#ifndef NDEBUG
- DEBUG1 (("\nSTORE LU: fnrows "ID
- " fncols "ID"\n", fnrows, fncols)) ;
+ DEBUG1 (("\nSTORE LU: 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 " 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")) ;
DEBUGm4 ((
"\n -------------------------------------------------------------"
- "Store LU: step " ID"\n", k)) ;
+ "Store LU: step " ID "\n", k)) ;
ASSERT (k < MIN (Work->n_row, Work->n_col)) ;
- DEBUG2 (("Store column of L, k = "ID", llen "ID"\n", k, llen)) ;
+ DEBUG2 (("Store column of L, k = " ID ", llen " ID "\n", k, llen)) ;
for (i = 0 ; i < llen ; i++)
{
row = Lpattern [i] ;
ASSERT (row >= 0 && row < Work->n_row) ;
- DEBUG2 ((" Lpattern["ID"] "ID" Lpos "ID, i, row, Lpos [row])) ;
+ DEBUG2 ((" Lpattern[" ID "] " ID " Lpos " ID, i, row, Lpos [row])) ;
if (row == pivrow) DEBUG2 ((" <- pivot row")) ;
DEBUG2 (("\n")) ;
ASSERT (i == Lpos [row]) ;
/* remove pivot row index from current column of L */
/* if a new Lchain starts, then all entries are removed later */
- DEBUG2 (("Removing pivrow from Lpattern, k = "ID"\n", k)) ;
+ DEBUG2 (("Removing pivrow from Lpattern, k = " ID "\n", k)) ;
ASSERT (!NON_PIVOTAL_ROW (pivrow)) ;
pivrow_position = Lpos [pivrow] ;
if (pivrow_position != EMPTY)
D [k] = pivot_value ;
zero_pivot = IS_ZERO (pivot_value) ;
- DEBUG4 (("Pivot D["ID"]=", k)) ;
+ DEBUG4 (("Pivot D[" ID "]=", k)) ;
EDEBUG4 (pivot_value) ;
DEBUG4 (("\n")) ;
if (newLchain)
{
/* start a new chain for column k of L */
- DEBUG2 (("Start new Lchain, k = "ID"\n", k)) ;
+ DEBUG2 (("Start new Lchain, k = " ID "\n", k)) ;
pivrow_position = EMPTY ;
else
{
/* continue the prior Lchain */
- DEBUG2 (("Continue Lchain, k = "ID"\n", k)) ;
+ DEBUG2 (("Continue Lchain, k = " ID "\n", k)) ;
lnzi = lnz2i ;
lnzx = lnz2x ;
}
#endif
}
- DEBUG4 (("llen "ID" lnzx "ID"\n", llen, lnzx)) ;
+ DEBUG4 (("llen " ID " lnzx " ID "\n", llen, lnzx)) ;
ASSERT (llen == lnzx) ;
ASSERT (lnz <= llen) ;
- DEBUG4 (("lnz "ID" \n", lnz)) ;
+ DEBUG4 (("lnz " ID " \n", lnz)) ;
#ifdef DROP
- DEBUG4 (("all_lnz "ID" \n", all_lnz)) ;
+ DEBUG4 (("all_lnz " ID " \n", all_lnz)) ;
ASSERT (lnz <= all_lnz) ;
Numeric->lnz += lnz ;
Numeric->all_lnz += all_lnz ;
ASSERT (pivrow >= 0 && pivrow < Work->n_row) ;
ASSERT (pivcol >= 0 && pivcol < Work->n_col) ;
- DEBUG2 (("Store row of U, k = "ID", ulen "ID"\n", k, ulen)) ;
+ DEBUG2 (("Store row of U, k = " ID ", ulen " ID "\n", k, ulen)) ;
for (i = 0 ; i < ulen ; i++)
{
col = Upattern [i] ;
- DEBUG2 ((" Upattern["ID"] "ID, i, col)) ;
+ DEBUG2 ((" Upattern[" ID "] " ID, i, col)) ;
if (col == pivcol) DEBUG2 ((" <- pivot col")) ;
DEBUG2 (("\n")) ;
ASSERT (col >= 0 && col < Work->n_col) ;
unz = 0 ;
unz2i = 0 ;
unz2x = ulen ;
- DEBUG2 (("unz2x is "ID", lnzx "ID"\n", unz2x, lnzx)) ;
+ DEBUG2 (("unz2x is " ID ", lnzx " ID "\n", unz2x, lnzx)) ;
/* if row k does not end a Uchain, pivcol not included in ulen */
ASSERT (!NON_PIVOTAL_COL (pivcol)) ;
if (pivcol_position != EMPTY)
{
unz2x-- ;
- DEBUG2 (("(exclude pivcol) unz2x is now "ID"\n", unz2x)) ;
+ DEBUG2 (("(exclude pivcol) unz2x is now " ID "\n", unz2x)) ;
}
ASSERT (unz2x >= 0) ;
{
/* starting a new Uchain - flag this by negating Uip [k] */
uip = -uip ;
- DEBUG2 (("Start new Uchain, k = "ID"\n", k)) ;
+ DEBUG2 (("Start new Uchain, k = " ID "\n", k)) ;
pivcol_position = EMPTY ;
/* end the prior Uchain */
/* save the current Upattern, and then */
/* clear it and start a new Upattern */
- DEBUG2 (("Ending prior chain, k-1 = "ID"\n", k-1)) ;
+ DEBUG2 (("Ending prior chain, k-1 = " ID "\n", k-1)) ;
uilen = ulen ;
Ui = (Int *) (Numeric->Memory + p) ;
Numeric->isize += ulen ;
else
{
/* continue the prior Uchain */
- DEBUG2 (("Continue Uchain, k = "ID"\n", k)) ;
+ DEBUG2 (("Continue Uchain, k = " ID "\n", k)) ;
ASSERT (k > 0) ;
/* remove pivot col index from current row of U */
/* if a new Uchain starts, then all entries are removed later */
- DEBUG2 (("Removing pivcol from Upattern, k = "ID"\n", k)) ;
+ DEBUG2 (("Removing pivcol from Upattern, k = " ID "\n", k)) ;
if (pivcol_position != EMPTY)
{
ASSERT (ulen == unzx) ;
ASSERT (unz <= ulen) ;
- DEBUG4 (("unz "ID" \n", unz)) ;
+ DEBUG4 (("unz " ID " \n", unz)) ;
#ifdef DROP
- DEBUG4 (("all_unz "ID" \n", all_unz)) ;
+ DEBUG4 (("all_unz " ID " \n", all_unz)) ;
ASSERT (unz <= all_unz) ;
Numeric->unz += unz ;
Numeric->all_unz += all_unz ;
Numeric->nUentries += unzx ;
Work->ulen = ulen ;
- DEBUG1 (("Work->ulen = "ID" at end of pivot step, k: "ID"\n", ulen, k));
+ DEBUG1 (("Work->ulen = " ID " at end of pivot step, k: " ID "\n", ulen, k));
/* ------------------------------------------------------------------ */
/* the pivot row is the k-th row of U */
Int nz ;
ASSERT (n_col >= 0) ;
nz = (Ap != (Int *) NULL) ? Ap [n_col] : 0 ;
- DEBUG2 (("UMF_transpose: "ID"-by-"ID" nz "ID"\n", n_row, n_col, nz)) ;
+ DEBUG2 (("UMF_transpose: " ID "-by-" ID " nz " ID "\n", n_row, n_col, nz)) ;
#endif
if (check)
{
i = k ;
}
- DEBUG3 ((ID": W[i] "ID" Rp[k+1] "ID"\n", i, W [i], Rp [k+1])) ;
+ DEBUG3 ((ID ": W[i] " ID " Rp[k+1] " ID "\n", i, W [i], Rp [k+1])) ;
ASSERT (W [i] == Rp [k+1]) ;
}
DEBUG2 (("UMF_transpose, output matrix:\n")) ;
}
W [i]++ ;
#ifndef NDEBUG
- DEBUG1 ((ID " triplet: "ID" "ID" ", k, i, j)) ;
+ DEBUG1 ((ID " triplet: " ID " " ID " ", k, i, j)) ;
#ifdef DO_VALUES
{
Entry tt ;
{
/* make sure that kth triplet is mapped correctly */
p = Map [k] ;
- DEBUG1 (("First row map: Map ["ID"] = "ID"\n", k, p)) ;
+ DEBUG1 (("First row map: Map [" ID "] = " ID "\n", k, p)) ;
i = Ti [k] ;
j = Tj [k] ;
ASSERT (j == Rj [p]) ;
{
/* make sure that kth triplet is mapped correctly */
p = Map [k] ;
- DEBUG1 (("Second row map: Map ["ID"] = "ID"\n", k, p)) ;
+ DEBUG1 (("Second row map: Map [" ID "] = " ID "\n", k, p)) ;
i = Ti [k] ;
j = Tj [k] ;
ASSERT (j == Rj [p]) ;
{
/* make sure that kth triplet is mapped correctly */
p = Map [k] ;
- DEBUG1 (("Col map: Map ["ID"] = "ID"\t", k, p)) ;
+ DEBUG1 (("Col map: Map [" ID "] = " ID "\t", k, p)) ;
i = Ti [k] ;
j = Tj [k] ;
ASSERT (i == Ai [p]) ;
- DEBUG1 ((" i "ID" j "ID" Ap[j] "ID" p "ID" Ap[j+1] "ID"\n",
+ DEBUG1 ((" i " ID " j " ID " Ap[j] " ID " p " ID " Ap[j+1] " ID "\n",
i, j, Ap [j], p, Ap [j+1])) ;
ASSERT (Ap [j] <= p && p < Ap [j+1]) ;
}
n1 = Work->n1 ;
nel = Work->nel ;
- DEBUG3 (("TUPLE_LENGTHS: n_row "ID" n_col "ID" nel "ID"\n",
+ DEBUG3 (("TUPLE_LENGTHS: n_row " ID " n_col " ID " nel " ID "\n",
n_row, n_col, nel)) ;
ASSERT (nel < Work->elen) ;
{
usage += 1 + UNITS (Tuple, TUPLES (Col_tlen [col])) ;
dusage += 1 + DUNITS (Tuple, TUPLES (Col_tlen [col])) ;
- DEBUG0 ((" col: "ID" tlen "ID" usage so far: "ID"\n",
+ DEBUG0 ((" col: " ID " tlen " ID " usage so far: " ID "\n",
col, Col_tlen [col], usage)) ;
}
}
{
usage += 1 + UNITS (Tuple, TUPLES (Row_tlen [row])) ;
dusage += 1 + DUNITS (Tuple, TUPLES (Row_tlen [row])) ;
- DEBUG0 ((" row: "ID" tlen "ID" usage so far: "ID"\n",
+ DEBUG0 ((" row: " ID " tlen " ID " usage so far: " ID "\n",
row, Row_tlen [row], usage)) ;
}
}
- DEBUG0 (("UMF_build_tuples_usage "ID" %g\n", usage, dusage)) ;
+ DEBUG0 (("UMF_build_tuples_usage " ID " %g\n", usage, dusage)) ;
*p_dusage = dusage ;
return (usage) ;
n1 = Numeric->n1 ;
#ifndef NDEBUG
- DEBUG4 (("Usolve start: npiv = "ID" n = "ID"\n", npiv, n)) ;
+ DEBUG4 (("Usolve start: npiv = " ID " n = " ID "\n", npiv, n)) ;
for (j = 0 ; j < n ; j++)
{
- DEBUG4 (("Usolve start "ID": ", j)) ;
+ DEBUG4 (("Usolve start " ID ": ", j)) ;
EDEBUG4 (X [j]) ;
DEBUG4 (("\n")) ;
}
/* :: make last pivot row of U (singular matrices only) :: */
for (j = 0 ; j < deg ; j++)
{
- DEBUG1 (("Last row of U: j="ID"\n", j)) ;
- DEBUG1 (("Last row of U: Upattern[j]="ID"\n",
+ DEBUG1 (("Last row of U: j=" ID "\n", j)) ;
+ DEBUG1 (("Last row of U: Upattern[j]=" ID "\n",
Numeric->Upattern [j]) );
Pattern [j] = Numeric->Upattern [j] ;
}
xk = X [k] ;
for (j = 0 ; j < deg ; j++)
{
- DEBUG4 ((" k "ID" col "ID" value", k, Pattern [j])) ;
+ DEBUG4 ((" k " ID " col " ID " value", k, Pattern [j])) ;
EDEBUG4 (*xp) ;
DEBUG4 (("\n")) ;
/* xk -= X [Pattern [j]] * (*xp) ; */
/* next row is a new Uchain */
deg = ulen ;
ASSERT (IMPLIES (k == 0, deg == 0)) ;
- DEBUG4 (("end of chain for row of U "ID" deg "ID"\n", k-1, deg)) ;
+ DEBUG4 (("end of chain for row of U " ID " deg " ID "\n", k-1, deg)) ;
ip = (Int *) (Numeric->Memory + up) ;
for (j = 0 ; j < deg ; j++)
{
col = *ip++ ;
- DEBUG4 ((" k "ID" col "ID"\n", k-1, col)) ;
+ DEBUG4 ((" k " ID " col " ID "\n", k-1, col)) ;
ASSERT (k <= col) ;
Pattern [j] = col ;
}
else
{
deg -= ulen ;
- DEBUG4 (("middle of chain for row of U "ID" deg "ID"\n", k, deg)) ;
+ DEBUG4 (("middle of chain for row of U " ID " deg " ID "\n", k, deg)) ;
ASSERT (deg >= 0) ;
pos = Upos [k] ;
if (pos != EMPTY)
{
/* add the pivot column */
- DEBUG4 (("k "ID" add pivot entry at pos "ID"\n", k, pos)) ;
+ DEBUG4 (("k " ID " add pivot entry at pos " ID "\n", k, pos)) ;
ASSERT (pos >= 0 && pos <= deg) ;
Pattern [deg++] = Pattern [pos] ;
Pattern [pos] = k ;
{
deg = Uilen [k] ;
xk = X [k] ;
- DEBUG4 (("Singleton k "ID"\n", k)) ;
+ DEBUG4 (("Singleton k " ID "\n", k)) ;
if (deg > 0)
{
up = Uip [k] ;
Uval = (Entry *) (Numeric->Memory + up) ;
for (j = 0 ; j < deg ; j++)
{
- DEBUG4 ((" k "ID" col "ID" value", k, Ui [j])) ;
+ DEBUG4 ((" k " ID " col " ID " value", k, Ui [j])) ;
EDEBUG4 (Uval [j]) ;
DEBUG4 (("\n")) ;
/* xk -= X [Ui [j]] * Uval [j] ; */
#ifndef NDEBUG
for (j = 0 ; j < n ; j++)
{
- DEBUG4 (("Usolve done "ID": ", j)) ;
+ DEBUG4 (("Usolve done " ID ": ", j)) ;
EDEBUG4 (X [j]) ;
DEBUG4 (("\n")) ;
}
n1 = Numeric->n1 ;
#ifndef NDEBUG
- DEBUG4 (("Utsolve start: npiv "ID" n "ID"\n", npiv, n)) ;
+ DEBUG4 (("Utsolve start: npiv " ID " n " ID "\n", npiv, n)) ;
for (j = 0 ; j < n ; j++)
{
- DEBUG4 (("Utsolve start "ID": ", j)) ;
+ DEBUG4 (("Utsolve start " ID ": ", j)) ;
EDEBUG4 (X [j]) ;
DEBUG4 (("\n")) ;
}
for (k = 0 ; k < n1 ; k++)
{
- DEBUG4 (("Singleton k "ID"\n", k)) ;
+ DEBUG4 (("Singleton k " ID "\n", k)) ;
#ifndef NO_DIVIDE_BY_ZERO
/* Go ahead and divide by zero if D [k] is zero. */
Uval = (Entry *) (Numeric->Memory + up) ;
for (j = 0 ; j < deg ; j++)
{
- DEBUG4 ((" k "ID" col "ID" value", k, Ui [j])) ;
+ DEBUG4 ((" k " ID " col " ID " value", k, Ui [j])) ;
EDEBUG4 (Uval [j]) ;
DEBUG4 (("\n")) ;
#ifdef CONJUGATE_SOLVE
/* find the end of this Uchain */
/* ------------------------------------------------------------------ */
- DEBUG4 (("kstart "ID" kend "ID"\n", kstart, kend)) ;
+ DEBUG4 (("kstart " ID " kend " ID "\n", kstart, kend)) ;
/* for (kend = kstart ; kend < npiv && Uip [kend+1] > 0 ; kend++) ; */
kend = kstart ;
while (kend < npiv && Uip [kend+1] > 0)
/* ------------------------------------------------------------------ */
k = kend+1 ;
- DEBUG4 (("\nKend "ID" K "ID"\n", kend, k)) ;
+ DEBUG4 (("\nKend " ID " K " ID "\n", kend, k)) ;
/* ------------------------------------------------------------------ */
/* start with last row in Uchain of U in Pattern [0..deg-1] */
up = -Uip [k] ;
ASSERT (up > 0) ;
deg = Uilen [k] ;
- DEBUG4 (("end of chain for row of U "ID" deg "ID"\n", k-1, deg)) ;
+ DEBUG4 (("end of chain for row of U " ID " deg " ID "\n", k-1, deg)) ;
ip = (Int *) (Numeric->Memory + up) ;
for (j = 0 ; j < deg ; j++)
{
col = *ip++ ;
- DEBUG4 ((" k "ID" col "ID"\n", k-1, col)) ;
+ DEBUG4 ((" k " ID " col " ID "\n", k-1, col)) ;
ASSERT (k <= col) ;
Pattern [j] = col ;
}
ASSERT (uhead >= deg) ;
Pattern [--uhead] = Pattern [--deg] ;
}
- DEBUG4 (("middle of chain for row of U "ID" deg "ID"\n", k, deg)) ;
+ DEBUG4 (("middle of chain for row of U " ID " deg " ID "\n", k, deg)) ;
ASSERT (deg >= 0) ;
pos = Upos [k] ;
if (pos != EMPTY)
{
/* add the pivot column */
- DEBUG4 (("k "ID" add pivot entry at position "ID"\n", k, pos)) ;
+ DEBUG4 (("k " ID " add pivot entry at position " ID "\n", k, pos)) ;
ASSERT (pos >= 0 && pos <= deg) ;
Pattern [deg++] = Pattern [pos] ;
Pattern [pos] = k ;
if (pos != EMPTY)
{
/* remove the pivot column */
- DEBUG4 (("k "ID" add pivot entry at position "ID"\n", k, pos)) ;
+ DEBUG4 (("k " ID " add pivot entry at position " ID "\n", k, pos)) ;
ASSERT (k > kstart) ;
ASSERT (pos >= 0 && pos < deg) ;
ASSERT (Pattern [pos] == k) ;
ASSERT (deg <= uhead && uhead < n) ;
Pattern [deg++] = Pattern [uhead++] ;
}
- DEBUG4 (("middle of chain, row of U "ID" deg "ID"\n", k, deg)) ;
+ DEBUG4 (("middle of chain, row of U " ID " deg " ID "\n", k, deg)) ;
ASSERT (deg >= 0) ;
}
}
for (j = 0 ; j < deg ; j++)
{
- DEBUG4 ((" k "ID" col "ID" value", k, Pattern [j])) ;
+ DEBUG4 ((" k " ID " col " ID " value", k, Pattern [j])) ;
EDEBUG4 (*xp) ;
DEBUG4 (("\n")) ;
#ifdef CONJUGATE_SOLVE
#ifndef NDEBUG
for (j = 0 ; j < n ; j++)
{
- DEBUG4 (("Utsolve done "ID": ", j)) ;
+ DEBUG4 (("Utsolve done " ID ": ", j)) ;
EDEBUG4 (X [j]) ;
DEBUG4 (("\n")) ;
}
/* singletons */
for (k = 0 ; k < n1 ; k++)
{
- DEBUG4 (("Singleton k "ID"\n", k)) ;
+ DEBUG4 (("Singleton k " ID "\n", k)) ;
deg = Lilen [k] ;
if (deg > 0)
{
{
row = Li [j] ;
value = Lval [j] ;
- DEBUG4 ((" row "ID" k "ID" value", row, k)) ;
+ DEBUG4 ((" row " ID " k " ID " value", row, k)) ;
EDEBUG4 (value) ;
DEBUG4 (("\n")) ;
if (IS_NONZERO (value))
pos = Lpos [k] ;
if (pos != EMPTY)
{
- DEBUG4 ((" k "ID" removing row "ID" at position "ID"\n",
+ DEBUG4 ((" k " ID " removing row " ID " at position " ID "\n",
k, Pattern [pos], pos)) ;
ASSERT (!newLchain) ;
ASSERT (deg > 0) ;
for (j = 0 ; j < llen ; j++)
{
row = *ip++ ;
- DEBUG4 ((" row "ID" k "ID"\n", row, k)) ;
+ DEBUG4 ((" row " ID " k " ID "\n", row, k)) ;
ASSERT (row > k && row < n_row) ;
Pattern [deg++] = row ;
}
for (j = 0 ; j < deg ; j++)
{
- DEBUG4 ((" row "ID" k "ID" value", Pattern [j], k)) ;
+ DEBUG4 ((" row " ID " k " ID " value", Pattern [j], k)) ;
row = Pattern [j] ;
value = *xp++ ;
EDEBUG4 (value) ;
/* add entries from the rows of L (singletons) */
for (k = 0 ; k < n1 ; k++)
{
- DEBUG4 (("Singleton k "ID"\n", k)) ;
+ DEBUG4 (("Singleton k " ID "\n", k)) ;
deg = Lilen [k] ;
if (deg > 0)
{
{
row = Li [j] ;
value = Lval [j] ;
- DEBUG4 ((" row "ID" k "ID" value", row, k)) ;
+ DEBUG4 ((" row " ID " k " ID " value", row, k)) ;
EDEBUG4 (value) ;
DEBUG4 (("\n")) ;
if (IS_NONZERO (value))
pos = Lpos [k] ;
if (pos != EMPTY)
{
- DEBUG4 ((" k "ID" removing row "ID" at position "ID"\n",
+ DEBUG4 ((" k " ID " removing row " ID " at position " ID "\n",
k, Pattern [pos], pos)) ;
ASSERT (!newLchain) ;
ASSERT (deg > 0) ;
for (j = 0 ; j < llen ; j++)
{
row = *ip++ ;
- DEBUG4 ((" row "ID" k "ID"\n", row, k)) ;
+ DEBUG4 ((" row " ID " k " ID "\n", row, k)) ;
ASSERT (row > k) ;
Pattern [deg++] = row ;
}
for (j = 0 ; j < deg ; j++)
{
- DEBUG4 ((" row "ID" k "ID" value", Pattern [j], k)) ;
+ DEBUG4 ((" row " ID " k " ID " value", Pattern [j], k)) ;
row = Pattern [j] ;
value = *xp++ ;
EDEBUG4 (value) ;
for (col = 0 ; col < npiv ; col++)
{
/* include the diagonal entry in the column counts */
- DEBUG4 (("D ["ID"] = ", col)) ;
+ DEBUG4 (("D [" ID "] = ", col)) ;
EDEBUG4 (D [col]) ;
Wi [col] = IS_NONZERO (D [col]) ;
- DEBUG4 ((" is nonzero: "ID"\n", Wi [col])) ;
+ DEBUG4 ((" is nonzero: " ID "\n", Wi [col])) ;
#ifndef NDEBUG
nnzpiv += IS_NONZERO (D [col]) ;
#endif
}
- DEBUG4 (("nnzpiv "ID" "ID"\n", nnzpiv, Numeric->nnzpiv)) ;
+ DEBUG4 (("nnzpiv " ID " " ID "\n", nnzpiv, Numeric->nnzpiv)) ;
ASSERT (nnzpiv == Numeric->nnzpiv) ;
for (col = npiv ; col < n_col ; col++)
{
if (deg > 0)
{
/* make last pivot row of U (singular matrices only) */
- DEBUG0 (("Last pivot row of U: ulen "ID"\n", deg)) ;
+ DEBUG0 (("Last pivot row of U: ulen " ID "\n", deg)) ;
for (j = 0 ; j < deg ; j++)
{
Pattern [j] = Numeric->Upattern [j] ;
- DEBUG0 ((" column "ID"\n", Pattern [j])) ;
+ DEBUG0 ((" column " ID "\n", Pattern [j])) ;
}
}
for (j = 0 ; j < deg ; j++)
{
- DEBUG4 ((" k "ID" col "ID" value\n", k, Pattern [j])) ;
+ DEBUG4 ((" k " ID " col " ID " value\n", k, Pattern [j])) ;
col = Pattern [j] ;
ASSERT (col >= 0 && col < n_col) ;
value = *xp++ ;
{
/* next row is a new Uchain */
deg = ulen ;
- DEBUG4 (("end of chain for row of U "ID" deg "ID"\n", k-1, deg)) ;
+ DEBUG4 (("end of chain for row of U " ID " deg " ID "\n", k-1, deg)) ;
ip = (Int *) (Numeric->Memory + up) ;
for (j = 0 ; j < deg ; j++)
{
col = *ip++ ;
- DEBUG4 ((" k "ID" col "ID"\n", k-1, col)) ;
+ DEBUG4 ((" k " ID " col " ID "\n", k-1, col)) ;
ASSERT (k <= col) ;
Pattern [j] = col ;
}
else
{
deg -= ulen ;
- DEBUG4 (("middle of chain for row of U "ID" deg "ID"\n", k-1, deg));
+ DEBUG4 (("middle of chain for row of U " ID " deg " ID "\n", k-1, deg));
ASSERT (deg >= 0) ;
pos = Upos [k] ;
if (pos != EMPTY)
{
/* add the pivot column */
- DEBUG4 (("k "ID" add pivot entry at position "ID"\n", k, pos)) ;
+ DEBUG4 (("k " ID " add pivot entry at position " ID "\n", k, pos)) ;
ASSERT (pos >= 0 && pos <= deg) ;
Pattern [deg++] = Pattern [pos] ;
Pattern [pos] = k ;
for (k = n1 - 1 ; k >= 0 ; k--)
{
deg = Uilen [k] ;
- DEBUG4 (("Singleton k "ID"\n", k)) ;
+ DEBUG4 (("Singleton k " ID "\n", k)) ;
if (deg > 0)
{
up = Uip [k] ;
{
col = Usi [j] ;
value = Uval [j] ;
- DEBUG4 ((" k "ID" col "ID" value", k, col)) ;
+ DEBUG4 ((" k " ID " col " ID " value", k, col)) ;
EDEBUG4 (value) ;
DEBUG4 (("\n")) ;
if (IS_NONZERO (value))
unz2 += Wi [col] ;
}
Up [n_col] = unz2 ;
- DEBUG1 (("Numeric->unz "ID" npiv "ID" nnzpiv "ID" unz2 "ID"\n",
+ DEBUG1 (("Numeric->unz " ID " npiv " ID " nnzpiv " ID " unz2 " ID "\n",
Numeric->unz, npiv, Numeric->nnzpiv, unz2)) ;
ASSERT (Numeric->unz + Numeric->nnzpiv == unz2) ;
xp += deg ;
for (j = deg-1 ; j >= 0 ; j--)
{
- DEBUG4 ((" k "ID" col "ID" value", k, Pattern [j])) ;
+ DEBUG4 ((" k " ID " col " ID " value", k, Pattern [j])) ;
col = Pattern [j] ;
ASSERT (col >= 0 && col < n_col) ;
value = *(--xp) ;
{
/* next row is a new Uchain */
deg = ulen ;
- DEBUG4 (("end of chain for row of U "ID" deg "ID"\n", k-1, deg)) ;
+ DEBUG4 (("end of chain for row of U " ID " deg " ID "\n", k-1, deg)) ;
ip = (Int *) (Numeric->Memory + up) ;
for (j = 0 ; j < deg ; j++)
{
col = *ip++ ;
- DEBUG4 ((" k "ID" col "ID"\n", k-1, col)) ;
+ DEBUG4 ((" k " ID " col " ID "\n", k-1, col)) ;
ASSERT (k <= col) ;
Pattern [j] = col ;
}
else
{
deg -= ulen ;
- DEBUG4 (("middle of chain for row of U "ID" deg "ID"\n", k-1, deg));
+ DEBUG4 (("middle of chain for row of U " ID " deg " ID "\n", k-1, deg));
ASSERT (deg >= 0) ;
pos = Upos [k] ;
if (pos != EMPTY)
{
/* add the pivot column */
- DEBUG4 (("k "ID" add pivot entry at position "ID"\n", k, pos)) ;
+ DEBUG4 (("k " ID " add pivot entry at position " ID "\n", k, pos)) ;
ASSERT (pos >= 0 && pos <= deg) ;
Pattern [deg++] = Pattern [pos] ;
Pattern [pos] = k ;
for (k = n1 - 1 ; k >= 0 ; k--)
{
deg = Uilen [k] ;
- DEBUG4 (("Singleton k "ID"\n", k)) ;
+ DEBUG4 (("Singleton k " ID "\n", k)) ;
if (deg > 0)
{
up = Uip [k] ;
{
col = Usi [j] ;
value = Uval [j] ;
- DEBUG4 ((" k "ID" col "ID" value", k, col)) ;
+ DEBUG4 ((" k " ID " col " ID " value", k, col)) ;
EDEBUG4 (value) ;
DEBUG4 (("\n")) ;
if (IS_NONZERO (value))
error (&Numeric, Work) ;
return (UMFPACK_ERROR_out_of_memory) ;
}
- DEBUG0 (("malloc: init_count "ID" UMF_malloc_count "ID"\n",
+ DEBUG0 (("malloc: init_count " ID " UMF_malloc_count " ID "\n",
init_count, UMF_malloc_count)) ;
ASSERT (UMF_malloc_count == init_count
+ (16 + 2*Symbolic->prefer_diagonal)
Info [UMFPACK_NOFF_DIAG] = Work->noff_diagonal ;
}
- DEBUG0 (("malloc: init_count "ID" UMF_malloc_count "ID"\n",
+ DEBUG0 (("malloc: init_count " ID " UMF_malloc_count " ID "\n",
init_count, UMF_malloc_count)) ;
npiv = Numeric->npiv ; /* = n_inner for nonsingular matrices */
* which is transfered to Numeric->Upattern if ulen > 0.
*/
- DEBUG0 (("malloc: init_count "ID" UMF_malloc_count "ID"\n",
+ DEBUG0 (("malloc: init_count " ID " UMF_malloc_count " ID "\n",
init_count, UMF_malloc_count)) ;
free_work (Work) ;
- DEBUG0 (("malloc: init_count "ID" UMF_malloc_count "ID"\n",
+ DEBUG0 (("malloc: init_count " ID " UMF_malloc_count " ID "\n",
init_count, UMF_malloc_count)) ;
- DEBUG0 (("Numeric->ulen: "ID" scale: "ID"\n", ulen, scale)) ;
+ DEBUG0 (("Numeric->ulen: " ID " scale: " ID "\n", ulen, scale)) ;
ASSERT (UMF_malloc_count == init_count + (ulen > 0) +
(11 + (scale != UMFPACK_SCALE_NONE))) ;
* from size n_col+1 to size ulen + 1. If ulen is zero, the object does
* not exist. */
- DEBUG4 (("ulen: "ID" Upattern "ID"\n", ulen, (Int) Numeric->Upattern)) ;
+ DEBUG4 (("ulen: " ID " Upattern " ID "\n", ulen, (Int) Numeric->Upattern)) ;
ASSERT (IMPLIES (ulen == 0, Numeric->Upattern == (Int *) NULL)) ;
if (ulen > 0 && ulen < n_col)
{
{
/* there are zeros and/or NaN's on the diagonal of U */
DEBUG0 (("Warning, matrix is singular in umfpack_numeric\n")) ;
- DEBUG0 (("nnzpiv "ID" n_inner "ID" rcond %g\n", Numeric->nnzpiv,
+ DEBUG0 (("nnzpiv " ID " n_inner " ID " rcond %g\n", Numeric->nnzpiv,
n_inner, Numeric->rcond)) ;
status = UMFPACK_WARNING_singular_matrix ;
Info [UMFPACK_STATUS] = status ;
Numeric->size = (Int) nsize ;
- DEBUG0 (("Num init %g usage_est %g numsize "ID" minusage "ID"\n",
+ DEBUG0 (("Num init %g usage_est %g numsize " ID " minusage " ID "\n",
alloc_init, Symbolic->num_mem_usage_est, Numeric->size, min_usage)) ;
/* allocates 1 object: */
Numeric->Memory = (Unit *) UMF_malloc (Numeric->size, sizeof (Unit)) ;
if (Numeric->Memory)
{
- DEBUG0 (("Successful Numeric->size: "ID"\n", Numeric->size)) ;
+ DEBUG0 (("Successful Numeric->size: " ID "\n", Numeric->size)) ;
return (TRUE) ;
}
/* too much, reduce the request (but not below the minimum) */
maxncols = MIN (n_col, maxncols) ;
maxnrc = MAX (maxnrows, maxncols) ;
- DEBUG0 (("work alloc: maxnrows+nb "ID" maxncols+nb "ID"\n",
+ DEBUG0 (("work alloc: maxnrows+nb " ID " maxncols+nb " ID "\n",
maxnrows, maxncols)) ;
/* 15 allocations, freed in free_work: */
{
oldcol = Cperm1 [k] ;
newcol = k - n1 ;
- DEBUG5 (("Prune singletons k "ID" oldcol "ID" newcol "ID": "ID"\n",
+ DEBUG5 (("Prune singletons k " ID " oldcol " ID " newcol " ID ": " ID "\n",
k, oldcol, newcol, pp)) ;
Sp [newcol] = pp ; /* load column pointers */
for (p = Ap [oldcol] ; p < Ap [oldcol+1] ; p++)
{
row = Ai [p] ;
- DEBUG5 ((" "ID": row "ID, pp, row)) ;
+ DEBUG5 ((" " ID ": row " ID, pp, row)) ;
ASSERT (row >= 0 && row < n_row) ;
newrow = InvRperm1 [row] - n1 ;
ASSERT (newrow < n_row - n1) ;
if (newrow >= 0)
{
- DEBUG5 ((" newrow "ID, newrow)) ;
+ DEBUG5 ((" newrow " ID, newrow)) ;
Si [pp++] = newrow ;
if (do_nzdiag)
{
#endif
for (k = 0 ; k < n1 ; k++)
{
- DEBUG1 ((ID" Initial singleton: "ID"\n", k, Cperm1 [k])) ;
+ DEBUG1 ((ID " Initial singleton: " ID "\n", k, Cperm1 [k])) ;
Cperm_init [k] = Cperm1 [k] ;
}
for (k = n1 ; k < n_col - nempty_col ; k++)
newcol = k - n1 ; /* Qinv's name for this column */
knew = Qinv [newcol] ; /* Qinv's ordering for this column */
knew += n1 ; /* shift order, after singletons */
- DEBUG1 ((" k "ID" oldcol "ID" newcol "ID" knew "ID"\n",
+ DEBUG1 ((" k " ID " oldcol " ID " newcol " ID " knew " ID "\n",
k, oldcol, newcol, knew)) ;
ASSERT (knew >= 0 && knew < n_col - nempty_col) ;
ASSERT (Cperm_init [knew] == EMPTY) ;
nb = MIN (nb, MAXNB) ;
ASSERT (nb >= 0) ;
if (nb % 2 == 1) nb++ ; /* make sure nb is even */
- DEBUG0 (("UMFPACK_qsymbolic: nb = "ID" aggressive = "ID"\n", nb,
+ DEBUG0 (("UMFPACK_qsymbolic: nb = " ID " aggressive = " ID "\n", nb,
aggressive)) ;
tol = MAX (0.0, MIN (tol, 1.0)) ;
}
nz = Ap [n_col] ;
- DEBUG0 (("n_row "ID" n_col "ID" nz "ID"\n", n_row, n_col, nz)) ;
+ DEBUG0 (("n_row " ID " n_col " ID " nz " ID "\n", n_row, n_col, nz)) ;
Info [UMFPACK_NZ] = nz ;
if (nz < 0)
{
return (UMFPACK_ERROR_out_of_memory) ;
}
- DEBUG0 (("Symbolic UMF_malloc_count - init_count = "ID"\n",
+ DEBUG0 (("Symbolic UMF_malloc_count - init_count = " ID "\n",
UMF_malloc_count - init_count)) ;
ASSERT (UMF_malloc_count == init_count + 17) ;
ASSERT (Sdeg [k] >= 0 && Sdeg [k] < n2) ;
}
ASSERT (Sp [n2] - n2 <= nzaat && nzaat <= 2 * Sp [n2]) ;
- DEBUG0 (("Explicit zeros: "ID" %g\n", nzdiag, amd_Info [AMD_NZDIAG])) ;
+ DEBUG0 (("Explicit zeros: " ID " %g\n", nzdiag, amd_Info [AMD_NZDIAG])) ;
#endif
}
#endif
InvRperm1, n1, nempty, Sdeg, Rperm_2by2, &nweak, &unmatched,
Ri, Rp, SW->Rs, Blen, W, Ci, Wq) ;
- DEBUGm3 (("2by2: nweak "ID" unmatched "ID"\n", nweak, unmatched)) ;
+ DEBUGm3 (("2by2: nweak " ID " unmatched " ID "\n", nweak, unmatched)) ;
Info [UMFPACK_2BY2_NWEAK] = nweak ;
Info [UMFPACK_2BY2_UNMATCHED] = unmatched ;
Info [UMFPACK_2BY2_NZ_PA_PLUS_PAT] = nz_papat ;
Info [UMFPACK_2BY2_NZDIAG] = nzd2 ;
- DEBUG0 (("2by2: sym2 %g nzd2 "ID" n2 "ID"\n", sym2, nzd2, n2)) ;
+ DEBUG0 (("2by2: sym2 %g nzd2 " ID " n2 " ID "\n", sym2, nzd2, n2)) ;
/* ------------------------------------------------------------------ */
/* evaluate the 2-by-2 results */
DEBUG0 (("Force fixQ false\n")) ;
}
- DEBUG0 (("Strategy: ordering: "ID"\n", Symbolic->ordering)) ;
- DEBUG0 (("Strategy: fixQ: "ID"\n", fixQ)) ;
- DEBUG0 (("Strategy: prefer diag "ID"\n", prefer_diagonal)) ;
+ DEBUG0 (("Strategy: ordering: " ID "\n", Symbolic->ordering)) ;
+ DEBUG0 (("Strategy: fixQ: " ID "\n", fixQ)) ;
+ DEBUG0 (("Strategy: prefer diag " ID "\n", prefer_diagonal)) ;
/* get statistics from amd_aat, if computed */
Symbolic->strategy = strategy ;
#ifndef NDEBUG
for (col = 0 ; col < n_col ; col++)
{
- DEBUG1 (("Cperm_init ["ID"] = "ID"\n", col, Cperm_init[col]));
+ DEBUG1 (("Cperm_init [" ID "] = " ID "\n", col, Cperm_init[col]));
}
/* make sure colamd returned a valid permutation */
ASSERT (Cperm_init != (Int *) NULL) ;
ASSERT (UMF_is_permutation (Cperm_init, Ci, n_col, n_col)) ;
for (k = 0 ; k < n_col ; k++)
{
- DEBUG3 ((ID"\n", Cperm_init [k])) ;
+ DEBUG3 ((ID "\n", Cperm_init [k])) ;
}
/* ensure that empty columns have been placed last in A (:,Cperm_init) */
for (newj = 0 ; newj < n_col ; newj++)
ASSERT (UMF_is_permutation (P, W, n_row - n1, n_row - n1)) ;
for (k = 0 ; k < n_row - n1 ; k++)
{
- DEBUG3 ((ID"\n", P [k])) ;
+ DEBUG3 ((ID "\n", P [k])) ;
}
#endif
SYM_WORK_USAGE (n_col, n_row, Clen) + Info [UMFPACK_SYMBOLIC_SIZE] ;
Symbolic->peak_sym_usage = Info [UMFPACK_SYMBOLIC_PEAK_MEMORY] ;
- DEBUG0 (("Number of fronts: "ID"\n", nfr)) ;
+ DEBUG0 (("Number of fronts: " ID "\n", nfr)) ;
/* ---------------------------------------------------------------------- */
/* allocate the second part of the Symbolic object (Front_*, Chain_*) */
error (&Symbolic, SW) ;
return (UMFPACK_ERROR_out_of_memory) ;
}
- DEBUG0 (("Symbolic UMF_malloc_count - init_count = "ID"\n",
+ DEBUG0 (("Symbolic UMF_malloc_count - init_count = " ID "\n",
UMF_malloc_count - init_count)) ;
ASSERT (UMF_malloc_count == init_count + 21
+ (SW->Rperm_2by2 != (Int *) NULL)
row = Rperm1 [k] ;
InFront [row] = EMPTY ;
}
- DEBUG1 (("Front (EMPTY), singleton nrows "ID" ncols "ID"\n", k, k)) ;
+ DEBUG1 (("Front (EMPTY), singleton nrows " ID " ncols " ID "\n", k, k)) ;
newj = n1 ;
for (i = 0 ; i < nfr ; i++)
{
if (InFront [row] == nfr)
{
/* this row belongs to front i */
- DEBUG1 ((" Row "ID" in Front "ID"\n", row, i)) ;
+ DEBUG1 ((" Row " ID " in Front " ID "\n", row, i)) ;
InFront [row] = i ;
f1rows++ ;
}
}
}
Front_1strow [i] = f1rows ;
- DEBUG1 ((" Front "ID" has 1strows: "ID" pivcols "ID"\n",
+ DEBUG1 ((" Front " ID " has 1strows: " ID " pivcols " ID "\n",
i, f1rows, fpivcol)) ;
}
{
if (InFront [row] == nfr)
{
- DEBUG1 ((" Row "ID" in Dummy Front "ID"\n", row, nfr)) ;
+ DEBUG1 ((" Row " ID " in Dummy Front " ID "\n", row, nfr)) ;
}
else if (InFront [row] == EMPTY)
{
- DEBUG1 ((" singleton Row "ID"\n", row)) ;
+ DEBUG1 ((" singleton Row " ID "\n", row)) ;
}
else
{
- DEBUG1 ((" Row "ID" in Front "ID"\n", row, nfr)) ;
+ DEBUG1 ((" Row " ID " in Front " ID "\n", row, nfr)) ;
}
}
#endif
for (i = 0 ; i < nfr ; i++)
{
fpivcol = Fr_npivcol [i] ;
- DEBUG1 (("Front "ID" k "ID" npivcol "ID" nrows "ID" ncols "ID"\n",
+ DEBUG1 (("Front " ID " k " ID " npivcol " ID " nrows " ID " ncols " ID "\n",
i, k, fpivcol, Fr_nrows [i], Fr_ncols [i])) ;
k += fpivcol ;
/* copy Front info into Symbolic object from SW */
}
/* assign empty columns to dummy placehold front nfr */
- DEBUG1 (("Dummy Cols in Front "ID" : "ID"\n", nfr, n_col-k)) ;
+ DEBUG1 (("Dummy Cols in Front " ID " : " ID "\n", nfr, n_col-k)) ;
Front_npivcol [nfr] = n_col - k ;
Front_parent [nfr] = EMPTY ;
for (i = 0 ; i < nfr ; i++)
{
f1rows = Front_1strow [i] ;
- DEBUG1 (("Front "ID" : npivcol "ID" parent "ID,
+ DEBUG1 (("Front " ID " : npivcol " ID " parent " ID,
i, Front_npivcol [i], Front_parent [i])) ;
- DEBUG1 ((" 1st rows in Front "ID" : "ID"\n", i, f1rows)) ;
+ DEBUG1 ((" 1st rows in Front " ID " : " ID "\n", i, f1rows)) ;
Front_1strow [i] = k ;
k += f1rows ;
}
/* assign empty rows to dummy placehold front nfr */
- DEBUG1 (("Rows in Front "ID" (dummy): "ID"\n", nfr, n_row-k)) ;
+ DEBUG1 (("Rows in Front " ID " (dummy): " ID "\n", nfr, n_row-k)) ;
Front_1strow [nfr] = k ;
- DEBUG1 (("nfr "ID" 1strow[nfr] "ID" nrow "ID"\n", nfr, k, n_row)) ;
+ DEBUG1 (("nfr " ID " 1strow[nfr] " ID " nrow " ID "\n", nfr, k, n_row)) ;
/* Use Ci as temporary workspace for F1 */
F1 = Ci ; /* [ of size nfr+1 */
#ifndef NDEBUG
for (k = 0 ; k < n_row ; k++)
{
- DEBUG2 (("Rperm_init ["ID"] = "ID"\n", k, Rperm_init [k])) ;
+ DEBUG2 (("Rperm_init [" ID "] = " ID "\n", k, Rperm_init [k])) ;
}
#endif
for (newcol = 0 ; newcol < nn ; newcol++)
{
oldcol = Cperm_init [newcol] ;
- DEBUG3 (("oldcol "ID" newcol "ID":\n", oldcol, newcol)) ;
+ DEBUG3 (("oldcol " ID " newcol " ID ":\n", oldcol, newcol)) ;
for (p = Ap [oldcol] ; p < Ap [oldcol+1] ; p++)
{
Entry aij ;
}
if (oldrow == oldcol)
{
- DEBUG2 ((" old diagonal : oldcol "ID" oldrow "ID" ",
+ DEBUG2 ((" old diagonal : oldcol " ID " oldrow " ID " ",
oldcol, oldrow)) ;
EDEBUG2 (aij) ;
DEBUG2 (("\n")) ;
}
if (newrow == Diagonal_map [newcol])
{
- DEBUG2 ((" MAP diagonal : newcol "ID" MAProw "ID" ",
+ DEBUG2 ((" MAP diagonal : newcol " ID " MAProw " ID " ",
newcol, Diagonal_map [newrow])) ;
EDEBUG2 (aij) ;
DEBUG2 (("\n")) ;
for (i = 0 ; i < nfr ; i++)
{
/* start at i and walk up the tree */
- DEBUG2 (("Walk up front tree from "ID"\n", i)) ;
+ DEBUG2 (("Walk up front tree from " ID "\n", i)) ;
j = i ;
while (j != EMPTY && Front_leftmostdesc [j] == EMPTY)
{
- DEBUG3 ((" Leftmost desc of "ID" is "ID"\n", j, i)) ;
+ DEBUG3 ((" Leftmost desc of " ID " is " ID "\n", j, i)) ;
Front_leftmostdesc [j] = i ;
j = Front_parent [j] ;
- DEBUG3 ((" go to j = "ID"\n", j)) ;
+ DEBUG3 ((" go to j = " ID "\n", j)) ;
}
}
maxrows = MAX (maxrows, fallrows) ;
maxcols = MAX (maxcols, fallcols) ;
- DEBUG1 (("Front: "ID", pivcol "ID", "ID"-by-"ID" parent "ID
- ", npiv "ID" Chain: maxrows "ID" maxcols "ID"\n", i, fpivcol,
+ DEBUG1 (("Front: " ID ", pivcol " ID ", " ID "-by-" ID " parent " ID
+ ", npiv " ID " Chain: maxrows " ID " maxcols " ID "\n", i, fpivcol,
fallrows, fallcols, parent, fpiv, maxrows, maxcols)) ;
if (parent != i+1)
{
/* this is the end of a chain */
double s ;
- DEBUG1 (("\nEnd of chain "ID"\n", nchains)) ;
+ DEBUG1 (("\nEnd of chain " ID "\n", nchains)) ;
/* make sure maxrows is an odd number */
ASSERT (maxrows >= 0) ;
if (maxrows % 2 == 0) maxrows++ ;
- DEBUG1 (("Chain maxrows "ID" maxcols "ID"\n", maxrows, maxcols)) ;
+ DEBUG1 (("Chain maxrows " ID " maxcols " ID "\n", maxrows, maxcols)) ;
Chain_maxrows [nchains] = maxrows ;
Chain_maxcols [nchains] = maxcols ;
/* for Info only: */
dmaxfrsize = ceil (dmaxfrsize) ;
- DEBUGm1 (("dmaxfrsize %30.20g Int_MAX "ID"\n", dmaxfrsize, Int_MAX)) ;
+ DEBUGm1 (("dmaxfrsize %30.20g Int_MAX " ID "\n", dmaxfrsize, Int_MAX)) ;
ASSERT (Symbolic->nchains == nchains) ;
/* For allocating objects in umfpack_numeric (does not include all possible
* matrix. maxnrows is always odd. */
Symbolic->maxnrows = maxnrows ;
Symbolic->maxncols = maxncols ;
- DEBUGm3 (("maxnrows "ID" maxncols "ID"\n", maxnrows, maxncols)) ;
+ DEBUGm3 (("maxnrows " ID " maxncols " ID "\n", maxnrows, maxncols)) ;
/* ---------------------------------------------------------------------- */
/* find the initial element sizes */
/* allocate the Rpi and Rpx workspace for UMF_kernel_init (incl. headers) */
tail_usage += UNITS (Int *, n_row+1) + UNITS (Entry *, n_row+1) + 2 ;
dtail_usage += DUNITS (Int *, n_row+1) + DUNITS (Entry *, n_row+1) + 2 ;
- DEBUG1 (("Symbolic usage after Rpi/Rpx allocation: head "ID" tail "ID"\n",
+ DEBUG1 (("Symbolic usage after Rpi/Rpx allocation: head " ID " tail " ID "\n",
head_usage, tail_usage)) ;
/* LU factors for singletons, at the head of memory */
unz = Rdeg [k] - 1 ;
dlnz += lnz ;
dunz += unz ;
- DEBUG1 (("singleton k "ID" pivrow "ID" pivcol "ID" lnz "ID" unz "ID"\n",
+ DEBUG1 (("singleton k " ID " pivrow " ID " pivcol " ID " lnz " ID " unz " ID "\n",
k, Rperm_init [k], Cperm_init [k], lnz, unz)) ;
head_usage += UNITS (Int, lnz) + UNITS (Entry, lnz)
+ UNITS (Int, unz) + UNITS (Entry, unz) ;
dhead_usage += DUNITS (Int, lnz) + DUNITS (Entry, lnz)
+ DUNITS (Int, unz) + DUNITS (Entry, unz) ;
}
- DEBUG1 (("Symbolic init head usage: "ID" for LU singletons\n",head_usage)) ;
+ DEBUG1 (("Symbolic init head usage: " ID " for LU singletons\n",head_usage)) ;
/* column elements: */
for (k = n1 ; k < n_col - nempty_col; k++)
{
esize = Esize ? Esize [k-n1] : Cdeg [k] ;
- DEBUG2 ((" esize: "ID"\n", esize)) ;
+ DEBUG2 ((" esize: " ID "\n", esize)) ;
ASSERT (esize >= 0) ;
if (esize > 0)
{
Info [UMFPACK_NDENSE_ROW] = nrow_elements ;
}
- DEBUG1 (("Symbolic usage: "ID" = head "ID" + tail "ID" after els\n",
+ DEBUG1 (("Symbolic usage: " ID " = head " ID " + tail " ID " after els\n",
head_usage + tail_usage, head_usage, tail_usage)) ;
/* compute the tuple lengths */
}
Symbolic->num_mem_init_usage = head_usage + tail_usage ;
- DEBUG1 (("Symbolic usage: "ID" = head "ID" + tail "ID" final\n",
+ DEBUG1 (("Symbolic usage: " ID " = head " ID " + tail " ID " final\n",
Symbolic->num_mem_init_usage, head_usage, tail_usage)) ;
ASSERT (UMF_is_permutation (Rperm_init, Ci, n_row, n_row)) ;
#ifndef NDEBUG
for (i = 0 ; i < nchains ; i++)
{
- DEBUG2 (("Chain "ID" start "ID" end "ID" maxrows "ID" maxcols "ID"\n",
+ DEBUG2 (("Chain " ID " start " ID " end " ID " maxrows " ID " maxcols " ID "\n",
i, Chain_start [i], Chain_start [i+1] - 1,
Chain_maxrows [i], Chain_maxcols [i])) ;
UMF_dump_chain (Chain_start [i], Fr_parent, Fr_npivcol, Fr_nrows,
{
fpivcol = MAX (fpivcol, Front_npivcol [i]) ;
}
- DEBUG0 (("Max pivot cols in any front: "ID"\n", fpivcol)) ;
- DEBUG1 (("Largest front: maxnrows "ID" maxncols "ID" dmaxfrsize %g\n",
+ DEBUG0 (("Max pivot cols in any front: " ID "\n", fpivcol)) ;
+ DEBUG1 (("Largest front: maxnrows " ID " maxncols " ID " dmaxfrsize %g\n",
maxnrows, maxncols, dmaxfrsize)) ;
#endif
free_work (SW) ;
- DEBUG0 (("(3)Symbolic UMF_malloc_count - init_count = "ID"\n",
+ DEBUG0 (("(3)Symbolic UMF_malloc_count - init_count = " ID "\n",
UMF_malloc_count - init_count)) ;
ASSERT (UMF_malloc_count == init_count + 12
+ (Symbolic->Esize != (Int *) NULL)
/* printing level */
/* ---------------------------------------------------------------------- */
- PRINTF (("\n "ID": print level: "ID"\n",
+ PRINTF (("\n " ID ": print level: " ID "\n",
(Int) INDEX (UMFPACK_PRL), prl)) ;
/* ---------------------------------------------------------------------- */
drow = GET_CONTROL (UMFPACK_DENSE_ROW, UMFPACK_DEFAULT_DENSE_ROW) ;
dcol = GET_CONTROL (UMFPACK_DENSE_COL, UMFPACK_DEFAULT_DENSE_COL) ;
- PRINTF ((" "ID": dense row parameter: %g\n",
+ PRINTF ((" " ID ": dense row parameter: %g\n",
(Int) INDEX (UMFPACK_DENSE_ROW), drow)) ;
PRINTF ((" \"dense\" rows have > max (16, (%g)*16*sqrt(n_col)"
" entries)\n", drow)) ;
- PRINTF ((" "ID": dense column parameter: %g\n",
+ PRINTF ((" " ID ": dense column parameter: %g\n",
(Int) INDEX (UMFPACK_DENSE_COL), dcol)) ;
PRINTF ((" \"dense\" columns have > max (16, (%g)*16*sqrt(n_row)"
" entries)\n", dcol)) ;
relpt = GET_CONTROL (UMFPACK_PIVOT_TOLERANCE,
UMFPACK_DEFAULT_PIVOT_TOLERANCE) ;
relpt = MAX (0.0, MIN (relpt, 1.0)) ;
- PRINTF ((" "ID": pivot tolerance: %g\n",
+ PRINTF ((" " ID ": pivot tolerance: %g\n",
(Int) INDEX (UMFPACK_PIVOT_TOLERANCE), relpt)) ;
/* ---------------------------------------------------------------------- */
nb = GET_CONTROL (UMFPACK_BLOCK_SIZE, UMFPACK_DEFAULT_BLOCK_SIZE) ;
nb = MAX (1, nb) ;
- PRINTF ((" "ID": block size for dense matrix kernels: "ID"\n",
+ PRINTF ((" " ID ": block size for dense matrix kernels: " ID "\n",
(Int) INDEX (UMFPACK_BLOCK_SIZE), nb)) ;
/* ---------------------------------------------------------------------- */
strategy = UMFPACK_STRATEGY_AUTO ;
}
- PRINTF ((" "ID": strategy: "ID,
+ PRINTF ((" " ID ": strategy: " ID,
(Int) INDEX (UMFPACK_STRATEGY), strategy)) ;
if (strategy == UMFPACK_STRATEGY_SYMMETRIC)
alloc_init = GET_CONTROL (UMFPACK_ALLOC_INIT, UMFPACK_DEFAULT_ALLOC_INIT) ;
if (alloc_init >= 0)
{
- PRINTF ((" "ID": initial allocation ratio: %g\n",
+ PRINTF ((" " ID ": initial allocation ratio: %g\n",
(Int) INDEX (UMFPACK_ALLOC_INIT), alloc_init)) ;
}
else
{
s = -alloc_init ;
s = MAX (1, s) ;
- PRINTF ((" "ID": initial allocation (in Units): "ID"\n",
+ PRINTF ((" " ID ": initial allocation (in Units): " ID "\n",
(Int) INDEX (UMFPACK_ALLOC_INIT), s)) ;
}
irstep = GET_CONTROL (UMFPACK_IRSTEP, UMFPACK_DEFAULT_IRSTEP) ;
irstep = MAX (0, irstep) ;
- PRINTF ((" "ID": max iterative refinement steps: "ID"\n",
+ PRINTF ((" " ID ": max iterative refinement steps: " ID "\n",
(Int) INDEX (UMFPACK_IRSTEP), irstep)) ;
/* ---------------------------------------------------------------------- */
tol = GET_CONTROL (UMFPACK_2BY2_TOLERANCE, UMFPACK_DEFAULT_2BY2_TOLERANCE) ;
tol = MAX (0.0, MIN (tol, 1.0)) ;
- PRINTF ((" "ID": 2-by-2 pivot tolerance: %g\n",
+ PRINTF ((" " ID ": 2-by-2 pivot tolerance: %g\n",
(Int) INDEX (UMFPACK_2BY2_TOLERANCE), tol)) ;
/* ---------------------------------------------------------------------- */
/* ---------------------------------------------------------------------- */
force_fixQ = GET_CONTROL (UMFPACK_FIXQ, UMFPACK_DEFAULT_FIXQ) ;
- PRINTF ((" "ID": Q fixed during numerical factorization: %g ",
+ PRINTF ((" " ID ": Q fixed during numerical factorization: %g ",
(Int) INDEX (UMFPACK_FIXQ), force_fixQ)) ;
if (force_fixQ > 0)
{
/* ---------------------------------------------------------------------- */
amd_alpha = GET_CONTROL (UMFPACK_AMD_DENSE, UMFPACK_DEFAULT_AMD_DENSE) ;
- PRINTF ((" "ID": AMD dense row/col parameter: %g\n",
+ PRINTF ((" " ID ": AMD dense row/col parameter: %g\n",
(Int) INDEX (UMFPACK_AMD_DENSE), amd_alpha)) ;
if (amd_alpha < 0)
{
relpt2 = GET_CONTROL (UMFPACK_SYM_PIVOT_TOLERANCE,
UMFPACK_DEFAULT_SYM_PIVOT_TOLERANCE) ;
relpt2 = MAX (0.0, MIN (relpt2, 1.0)) ;
- PRINTF ((" "ID": diagonal pivot tolerance: %g\n"
+ PRINTF ((" " ID ": diagonal pivot tolerance: %g\n"
" Only used if diagonal pivoting is attempted.\n",
(Int) INDEX (UMFPACK_SYM_PIVOT_TOLERANCE), relpt2)) ;
{
scale = UMFPACK_DEFAULT_SCALE ;
}
- PRINTF ((" "ID": scaling: "ID, (Int) INDEX (UMFPACK_SCALE), scale)) ;
+ PRINTF ((" " ID ": scaling: " ID, (Int) INDEX (UMFPACK_SCALE), scale)) ;
if (scale == UMFPACK_SCALE_NONE)
{
PRINTF ((" (no)")) ;
front_alloc_init = MIN (1.0, front_alloc_init) ;
if (front_alloc_init >= 0)
{
- PRINTF ((" "ID": frontal matrix allocation ratio: %g\n",
+ PRINTF ((" " ID ": frontal matrix allocation ratio: %g\n",
(Int) INDEX (UMFPACK_FRONT_ALLOC_INIT), front_alloc_init)) ;
}
else
{
s = -front_alloc_init ;
s = MAX (1, s) ;
- PRINTF ((" "ID": initial frontal matrix size (# of Entry's): "ID"\n",
+ PRINTF ((" " ID ": initial frontal matrix size (# of Entry's): " ID "\n",
(Int) INDEX (UMFPACK_FRONT_ALLOC_INIT), s)) ;
}
/* ---------------------------------------------------------------------- */
droptol = GET_CONTROL (UMFPACK_DROPTOL, UMFPACK_DEFAULT_DROPTOL) ;
- PRINTF ((" "ID": drop tolerance: %g\n",
+ PRINTF ((" " ID ": drop tolerance: %g\n",
(Int) INDEX (UMFPACK_DROPTOL), droptol)) ;
/* ---------------------------------------------------------------------- */
/* ---------------------------------------------------------------------- */
aggr = GET_CONTROL (UMFPACK_AGGRESSIVE, UMFPACK_DEFAULT_AGGRESSIVE) ;
- PRINTF ((" "ID": AMD and COLAMD aggressive absorption: %g",
+ PRINTF ((" " ID ": AMD and COLAMD aggressive absorption: %g",
(Int) INDEX (UMFPACK_AGGRESSIVE), aggr)) ;
if (aggr != 0.0)
{
PRINTF ((
"\n The following options can only be changed at compile-time:\n")) ;
- PRINTF ((" "ID": BLAS library used: ",
+ PRINTF ((" " ID ": BLAS library used: ",
(Int) INDEX (UMFPACK_COMPILED_WITH_BLAS))) ;
#ifdef NBLAS
PRINTF (("none. UMFPACK will be slow.\n")) ;
#else
- PRINTF (("Fortran BLAS. size of BLAS integer: "ID"\n",
+ PRINTF (("Fortran BLAS. size of BLAS integer: " ID "\n",
(Int) (sizeof (BLAS_INT)))) ;
#endif
#ifdef MATLAB_MEX_FILE
- PRINTF ((" "ID": compiled for MATLAB\n",
+ PRINTF ((" " ID ": compiled for MATLAB\n",
(Int) INDEX (UMFPACK_COMPILED_FOR_MATLAB))) ;
#else
#ifdef MATHWORKS
- PRINTF ((" "ID": compiled for MATLAB\n",
+ PRINTF ((" " ID ": compiled for MATLAB\n",
(Int) INDEX (UMFPACK_COMPILED_FOR_MATLAB))) ;
#else
- PRINTF ((" "ID": compiled for ANSI C\n",
+ PRINTF ((" " ID ": compiled for ANSI C\n",
(Int) INDEX (UMFPACK_COMPILED_FOR_MATLAB))) ;
#endif
#endif
#ifdef NO_TIMER
- PRINTF ((" "ID": no CPU timer \n",
+ PRINTF ((" " ID ": no CPU timer \n",
(Int) INDEX (UMFPACK_COMPILED_WITH_GETRUSAGE))) ;
#else
#ifndef NPOSIX
- PRINTF ((" "ID": CPU timer is POSIX times ( ) routine.\n",
+ PRINTF ((" " ID ": CPU timer is POSIX times ( ) routine.\n",
(Int) INDEX (UMFPACK_COMPILED_WITH_GETRUSAGE))) ;
#else
#ifdef GETRUSAGE
- PRINTF ((" "ID": CPU timer is getrusage.\n",
+ PRINTF ((" " ID ": CPU timer is getrusage.\n",
(Int) INDEX (UMFPACK_COMPILED_WITH_GETRUSAGE))) ;
#else
- PRINTF ((" "ID": CPU timer is ANSI C clock (may wrap around).\n",
+ PRINTF ((" " ID ": CPU timer is ANSI C clock (may wrap around).\n",
(Int) INDEX (UMFPACK_COMPILED_WITH_GETRUSAGE))) ;
#endif
#endif
#ifndef NDEBUG
PRINTF ((
"**** Debugging enabled (UMFPACK will be exceedingly slow!) *****************\n"
-" "ID": compiled with debugging enabled. ",
+" " ID ": compiled with debugging enabled. ",
(Int) INDEX (UMFPACK_COMPILED_IN_DEBUG_MODE))) ;
#else
- PRINTF ((" "ID": compiled for normal operation (debugging disabled)\n",
+ PRINTF ((" " ID ": compiled for normal operation (debugging disabled)\n",
(Int) INDEX (UMFPACK_COMPILED_IN_DEBUG_MODE))) ;
#endif
#ifdef NBLAS
PRINTF (("none. UMFPACK will be slow.\n")) ;
#else
- PRINTF (("Fortran BLAS. size of BLAS integer: "ID"\n",
+ PRINTF (("Fortran BLAS. size of BLAS integer: " ID "\n",
(Int) (sizeof (BLAS_INT)))) ;
#endif
n_col = (Int) Info [UMFPACK_NCOL] ;
n_inner = MIN (n_row, n_col) ;
- PRINT_INFO (" number of rows in matrix A: "ID"\n", n_row) ;
- PRINT_INFO (" number of columns in matrix A: "ID"\n", n_col) ;
- PRINT_INFO (" entries in matrix A: "ID"\n",
+ PRINT_INFO (" number of rows in matrix A: " ID "\n", n_row) ;
+ PRINT_INFO (" number of columns in matrix A: " ID "\n", n_col) ;
+ PRINT_INFO (" entries in matrix A: " ID "\n",
(Int) Info [UMFPACK_NZ]) ;
- PRINT_INFO (" memory usage reported in: "ID"-byte Units\n",
+ PRINT_INFO (" memory usage reported in: " ID "-byte Units\n",
(Int) Info [UMFPACK_SIZE_OF_UNIT]) ;
- PRINT_INFO (" size of int: "ID" bytes\n",
+ PRINT_INFO (" size of int: " ID " bytes\n",
(Int) Info [UMFPACK_SIZE_OF_INT]) ;
- PRINT_INFO (" size of UF_long: "ID" bytes\n",
+ PRINT_INFO (" size of UF_long: " ID " bytes\n",
(Int) Info [UMFPACK_SIZE_OF_LONG]) ;
- PRINT_INFO (" size of pointer: "ID" bytes\n",
+ PRINT_INFO (" size of pointer: " ID " bytes\n",
(Int) Info [UMFPACK_SIZE_OF_POINTER]) ;
- PRINT_INFO (" size of numerical entry: "ID" bytes\n",
+ PRINT_INFO (" size of numerical entry: " ID " bytes\n",
(Int) Info [UMFPACK_SIZE_OF_ENTRY]) ;
/* ---------------------------------------------------------------------- */
n_i = n_col ;
}
- PRINTF (("%s-form matrix, n_row "ID" n_col "ID", ", vector, n_row, n_col)) ;
+ PRINTF (("%s-form matrix, n_row " ID " n_col " ID ", ", vector, n_row, n_col)) ;
if (n_row <= 0 || n_col <= 0)
{
}
nz = Ap [n] ;
- PRINTF (("nz = "ID". ", nz)) ;
+ PRINTF (("nz = " ID ". ", nz)) ;
if (nz < 0)
{
PRINTF (("ERROR: number of entries < 0\n\n")) ;
if (Ap [0] != 0)
{
- PRINTF (("ERROR: Ap ["ID"] = "ID" must be "ID"\n\n",
+ PRINTF (("ERROR: Ap [" ID "] = " ID " must be " ID "\n\n",
(Int) INDEX (0), INDEX (Ap [0]), (Int) INDEX (0))) ;
return (UMFPACK_ERROR_invalid_matrix) ;
}
{
if (Ap [k] < 0)
{
- PRINTF (("ERROR: Ap ["ID"] < 0\n\n", INDEX (k))) ;
+ PRINTF (("ERROR: Ap [" ID "] < 0\n\n", INDEX (k))) ;
return (UMFPACK_ERROR_invalid_matrix) ;
}
if (Ap [k] > nz)
{
- PRINTF (("ERROR: Ap ["ID"] > size of Ai\n\n", INDEX (k))) ;
+ PRINTF (("ERROR: Ap [" ID "] > size of Ai\n\n", INDEX (k))) ;
return (UMFPACK_ERROR_invalid_matrix) ;
}
}
length = Ap [k+1] - Ap [k] ;
if (length < 0)
{
- PRINTF (("ERROR: # entries in %s "ID" is < 0\n\n",
+ PRINTF (("ERROR: # entries in %s " ID " is < 0\n\n",
vector, INDEX (k))) ;
return (UMFPACK_ERROR_invalid_matrix) ;
}
p1 = Ap [k] ;
p2 = Ap [k+1] ;
length = p2 - p1 ;
- PRINTF4 (("\n %s "ID": start: "ID" end: "ID" entries: "ID"\n",
+ PRINTF4 (("\n %s " ID ": start: " ID " end: " ID " entries: " ID "\n",
vector, INDEX (k), p1, p2-1, length)) ;
ilast = EMPTY ;
for (p = p1 ; p < p2 ; p++)
{
i = Ai [p] ;
- PRINTF4 (("\t%s "ID" ", index, INDEX (i))) ;
+ PRINTF4 (("\t%s " ID " ", index, INDEX (i))) ;
if (do_values && prl >= 4)
{
PRINTF ((":")) ;
}
if (i < 0 || i >= n_i)
{
- PRINTF ((" ERROR: %s index "ID" out of range in %s "ID"\n\n",
+ PRINTF ((" ERROR: %s index " ID " out of range in %s " ID "\n\n",
index, INDEX (i), vector, INDEX (k))) ;
return (UMFPACK_ERROR_invalid_matrix) ;
}
if (i <= ilast)
{
- PRINTF ((" ERROR: %s index "ID" out of order (or duplicate) in "
- "%s "ID"\n\n", index, INDEX (i), vector, INDEX (k))) ;
+ PRINTF ((" ERROR: %s index " ID " out of order (or duplicate) in "
+ "%s " ID "\n\n", index, INDEX (i), vector, INDEX (k))) ;
return (UMFPACK_ERROR_invalid_matrix) ;
}
PRINTF4 (("\n")) ;
n_inner = MIN (n_row, n_col) ;
npiv = Numeric->npiv ;
- DEBUG1 (("n_row "ID" n_col "ID" nn "ID" n_inner "ID" npiv "ID"\n",
+ DEBUG1 (("n_row " ID " n_col " ID " nn " ID " n_inner " ID " npiv " ID "\n",
n_row, n_col, nn, n_inner, npiv)) ;
/* size of Numeric object, except Numeric->Memory and Numeric->Upattern */
+ ((Numeric->scale != UMFPACK_SCALE_NONE) ?
UNITS (Entry, n_row) : 0) ; /* Rs */
- DEBUG1 (("num fixed size: "ID"\n", num_fixed_size)) ;
- DEBUG1 (("Numeric->size "ID"\n", Numeric->size)) ;
- DEBUG1 (("ulen units "ID"\n", UNITS (Int, Numeric->ulen))) ;
+ DEBUG1 (("num fixed size: " ID "\n", num_fixed_size)) ;
+ DEBUG1 (("Numeric->size " ID "\n", Numeric->size)) ;
+ DEBUG1 (("ulen units " ID "\n", UNITS (Int, Numeric->ulen))) ;
/* size of Numeric->Memory is Numeric->size */
/* size of Numeric->Upattern is Numeric->ulen */
numeric_size = num_fixed_size + Numeric->size
+ UNITS (Int, Numeric->ulen) ;
- DEBUG1 (("numeric total size "ID"\n", numeric_size)) ;
+ DEBUG1 (("numeric total size " ID "\n", numeric_size)) ;
if (prl >= 4)
{
- PRINTF (("\n n_row: "ID" n_col: "ID"\n", n_row, n_col)) ;
+ PRINTF (("\n n_row: " ID " n_col: " ID "\n", n_row, n_col)) ;
PRINTF ((" relative pivot tolerance used: %g\n",
Numeric->relpt)) ;
Numeric->alloc_init)) ;
PRINTF ((" frontal matrix allocation parameter used: %g\n",
Numeric->front_alloc_init)) ;
- PRINTF ((" final total size of Numeric object (Units): "ID"\n",
+ PRINTF ((" final total size of Numeric object (Units): " ID "\n",
numeric_size)) ;
PRINTF ((" final total size of Numeric object (MBytes): %.1f\n",
MBYTES (numeric_size))) ;
- PRINTF ((" peak size of variable-size part (Units): "ID"\n",
+ PRINTF ((" peak size of variable-size part (Units): " ID "\n",
Numeric->max_usage)) ;
PRINTF ((" peak size of variable-size part (MBytes): %.1f\n",
MBYTES (Numeric->max_usage))) ;
- PRINTF ((" largest actual frontal matrix size: "ID"\n",
+ PRINTF ((" largest actual frontal matrix size: " ID "\n",
Numeric->maxfrsize)) ;
- PRINTF ((" memory defragmentations: "ID"\n",
+ PRINTF ((" memory defragmentations: " ID "\n",
Numeric->ngarbage)) ;
- PRINTF ((" memory reallocations: "ID"\n",
+ PRINTF ((" memory reallocations: " ID "\n",
Numeric->nrealloc)) ;
- PRINTF ((" costly memory reallocations: "ID"\n",
+ PRINTF ((" costly memory reallocations: " ID "\n",
Numeric->ncostly)) ;
- PRINTF ((" entries in compressed pattern (L and U): "ID"\n",
+ PRINTF ((" entries in compressed pattern (L and U): " ID "\n",
Numeric->isize)) ;
- PRINTF ((" number of nonzeros in L (excl diag): "ID"\n",
+ PRINTF ((" number of nonzeros in L (excl diag): " ID "\n",
Numeric->lnz)) ;
- PRINTF ((" number of entries stored in L (excl diag): "ID"\n",
+ PRINTF ((" number of entries stored in L (excl diag): " ID "\n",
Numeric->nLentries)) ;
- PRINTF ((" number of nonzeros in U (excl diag): "ID"\n",
+ PRINTF ((" number of nonzeros in U (excl diag): " ID "\n",
Numeric->unz)) ;
- PRINTF ((" number of entries stored in U (excl diag): "ID"\n",
+ PRINTF ((" number of entries stored in U (excl diag): " ID "\n",
Numeric->nUentries)) ;
PRINTF ((" factorization floating-point operations: %g\n",
Numeric->flops)) ;
- PRINTF ((" number of nonzeros on diagonal of U: "ID"\n",
+ PRINTF ((" number of nonzeros on diagonal of U: " ID "\n",
Numeric->nnzpiv)) ;
PRINTF ((" min abs. value on diagonal of U: %.5e\n",
Numeric->min_udiag)) ;
PRINTF ((" ...\n")) ;
prl-- ;
}
- PRINTF4 (("\n column "ID":", INDEX (k))) ;
- PRINTF4 ((" length "ID".\n", deg)) ;
+ PRINTF4 (("\n column " ID ":", INDEX (k))) ;
+ PRINTF4 ((" length " ID ".\n", deg)) ;
for (j = 0 ; j < deg ; j++)
{
row = Li [j] ;
- PRINTF4 (("\trow "ID" : ", INDEX (row))) ;
+ PRINTF4 (("\trow " ID " : ", INDEX (row))) ;
if (prl >= 4) PRINT_ENTRY (Lval [j]) ;
if (row <= k || row >= n_row)
{
prl-- ;
}
- PRINTF4 (("\n column "ID":", INDEX (k))) ;
+ PRINTF4 (("\n column " ID ":", INDEX (k))) ;
/* ------------------------------------------------------------------ */
/* make column of L in Pattern [0..deg-1] */
pos = Lpos [k] ;
if (pos != EMPTY)
{
- PRINTF4 ((" remove row "ID" at position "ID".",
+ PRINTF4 ((" remove row " ID " at position " ID ".",
INDEX (Pattern [pos]), INDEX (pos))) ;
valid = (!newLchain) && (deg > 0) && (pos < deg) && (pos >= 0)
&& (Pattern [pos] == k) ;
}
if (llen > 0)
{
- PRINTF4 ((" add "ID" entries.", llen)) ;
+ PRINTF4 ((" add " ID " entries.", llen)) ;
ip = (Int *) (Numeric->Memory + lp) ;
for (j = 0 ; j < llen ; j++)
{
/* print column k of L */
/* ------------------------------------------------------------------ */
- PRINTF4 ((" length "ID".", deg)) ;
+ PRINTF4 ((" length " ID ".", deg)) ;
if (newLchain)
{
PRINTF4 ((" Start of Lchain.")) ;
for (j = 0 ; j < deg ; j++)
{
row = Pattern [j] ;
- PRINTF4 (("\trow "ID" : ", INDEX (row))) ;
+ PRINTF4 (("\trow " ID " : ", INDEX (row))) ;
if (prl >= 4) PRINT_ENTRY (*xp) ;
if (row <= k || row >= n_row)
{
}
}
- PRINTF4 (("\n row "ID": length "ID". End of Uchain.\n", INDEX (npiv-1),
+ PRINTF4 (("\n row " ID ": length " ID ". End of Uchain.\n", INDEX (npiv-1),
deg)) ;
for (k = npiv-1 ; k >= n1 ; k--)
for (j = 0 ; j < deg ; j++)
{
col = Pattern [j] ;
- PRINTF4 (("\tcol "ID" :", INDEX (col))) ;
+ PRINTF4 (("\tcol " ID " :", INDEX (col))) ;
if (prl >= 4) PRINT_ENTRY (*xp) ;
if (col <= k || col >= n_col)
{
if (k > 0)
{
- PRINTF4 (("\n row "ID": ", INDEX (k-1))) ;
+ PRINTF4 (("\n row " ID ": ", INDEX (k-1))) ;
}
if (newUchain)
if (k > 0)
{
deg = ulen ;
- PRINTF4 (("length "ID". End of Uchain.\n", deg)) ;
+ PRINTF4 (("length " ID ". End of Uchain.\n", deg)) ;
if (up + (Int) UNITS (Int, ulen) > Numeric->size)
{
return (FALSE) ;
{
if (ulen > 0)
{
- PRINTF4 (("remove "ID" entries. ", ulen)) ;
+ PRINTF4 (("remove " ID " entries. ", ulen)) ;
}
deg -= ulen ;
if (deg < 0)
if (pos != EMPTY)
{
/* add the pivot column */
- PRINTF4 (("add column "ID" at position "ID". ",
+ PRINTF4 (("add column " ID " at position " ID ". ",
INDEX (k), INDEX (pos))) ;
if (pos < 0 || pos > deg)
{
Pattern [deg++] = Pattern [pos] ;
Pattern [pos] = k ;
}
- PRINTF4 (("length "ID".\n", deg)) ;
+ PRINTF4 (("length " ID ".\n", deg)) ;
}
}
PRINTF ((" ...\n")) ;
prl-- ;
}
- PRINTF4 (("\n row "ID":", INDEX (k))) ;
- PRINTF4 ((" length "ID".\n", deg)) ;
+ PRINTF4 (("\n row " ID ":", INDEX (k))) ;
+ PRINTF4 ((" length " ID ".\n", deg)) ;
for (j = 0 ; j < deg ; j++)
{
col = Ui [j] ;
- PRINTF4 (("\tcol "ID" : ", INDEX (col))) ;
+ PRINTF4 (("\tcol " ID " : ", INDEX (col))) ;
if (prl >= 4) PRINT_ENTRY (Uval [j]) ;
if (col <= k || col >= n_col)
{
break ;
default:
- PRINTF (("ERROR: Unrecognized error code: "ID"\n", status)) ;
+ PRINTF (("ERROR: Unrecognized error code: " ID "\n", status)) ;
}
PRINTF (("\n")) ;
{
PRINTF (("\n matrix to be factorized:\n")) ;
- PRINTF (("\tn_row: "ID" n_col: "ID"\n", n_row, n_col)) ;
- PRINTF (("\tnumber of entries: "ID"\n", nz)) ;
- PRINTF ((" block size used for dense matrix kernels: "ID"\n",
+ PRINTF (("\tn_row: " ID " n_col: " ID "\n", n_row, n_col)) ;
+ PRINTF (("\tnumber of entries: " ID "\n", nz)) ;
+ PRINTF ((" block size used for dense matrix kernels: " ID "\n",
Symbolic->nb)) ;
PRINTF ((" strategy used: ")) ;
Symbolic->peak_sym_usage,
MBYTES (Symbolic->peak_sym_usage))) ;
PRINTF ((" frontal matrices / supercolumns:\n")) ;
- PRINTF (("\tnumber of frontal chains: "ID"\n", nchains)) ;
- PRINTF (("\tnumber of frontal matrices: "ID"\n", nfr)) ;
- PRINTF (("\tlargest frontal matrix row dimension: "ID"\n", maxnrows)) ;
- PRINTF (("\tlargest frontal matrix column dimension: "ID"\n",maxncols));
+ PRINTF (("\tnumber of frontal chains: " ID "\n", nchains)) ;
+ PRINTF (("\tnumber of frontal matrices: " ID "\n", nfr)) ;
+ PRINTF (("\tlargest frontal matrix row dimension: " ID "\n", maxnrows)) ;
+ PRINTF (("\tlargest frontal matrix column dimension: " ID "\n",maxncols));
}
k = 0 ;
{
frontid1 = Chain_start [chain] ;
frontid2 = Chain_start [chain+1] - 1 ;
- PRINTF4 (("\n Frontal chain: "ID". Frontal matrices "ID" to "ID"\n",
+ PRINTF4 (("\n Frontal chain: " ID ". Frontal matrices " ID " to " ID "\n",
INDEX (chain), INDEX (frontid1), INDEX (frontid2))) ;
- PRINTF4 (("\tLargest frontal matrix in Frontal chain: "ID"-by-"ID"\n",
+ PRINTF4 (("\tLargest frontal matrix in Frontal chain: " ID "-by-" ID "\n",
Chain_maxrows [chain], Chain_maxcols [chain])) ;
for (frontid = frontid1 ; frontid <= frontid2 ; frontid++)
{
kk = Front_npivcol [frontid] ;
- PRINTF4 (("\tFront: "ID" pivot cols: "ID" (pivot columns "ID" to "
- ID")\n", INDEX (frontid), kk, INDEX (k), INDEX (k+kk-1))) ;
- PRINTF4 (("\t pivot row candidates: "ID" to "ID"\n",
+ PRINTF4 (("\tFront: " ID " pivot cols: " ID " (pivot columns " ID " to "
+ ID ")\n", INDEX (frontid), kk, INDEX (k), INDEX (k+kk-1))) ;
+ PRINTF4 (("\t pivot row candidates: " ID " to " ID "\n",
INDEX (Front_1strow [Front_leftmostdesc [frontid]]),
INDEX (Front_1strow [frontid+1]-1))) ;
- PRINTF4 (("\t leftmost descendant: "ID"\n",
+ PRINTF4 (("\t leftmost descendant: " ID "\n",
INDEX (Front_leftmostdesc [frontid]))) ;
- PRINTF4 (("\t 1st new candidate row : "ID"\n",
+ PRINTF4 (("\t 1st new candidate row : " ID "\n",
INDEX (Front_1strow [frontid]))) ;
PRINTF4 (("\t parent:")) ;
if (Front_parent [frontid] == EMPTY)
}
else
{
- PRINTF4 ((" "ID"\n", INDEX (Front_parent [frontid]))) ;
+ PRINTF4 ((" " ID "\n", INDEX (Front_parent [frontid]))) ;
}
done = (frontid == 20 && frontid < nfr-1 && prl == 4) ;
if (done)
}
if (Front_npivcol [nfr] != 0)
{
- PRINTF4 (("\tFront: "ID" placeholder for "ID" empty columns\n",
+ PRINTF4 (("\tFront: " ID " placeholder for " ID " empty columns\n",
INDEX (nfr), Front_npivcol [nfr])) ;
}
if (done)
return (UMFPACK_OK) ;
}
- PRINTF (("triplet-form matrix, n_row = "ID", n_col = "ID" nz = "ID". ",
+ PRINTF (("triplet-form matrix, n_row = " ID ", n_col = " ID " nz = " ID ". ",
n_row, n_col, nz)) ;
if (!Ti || !Tj)
{
i = Ti [k] ;
j = Tj [k] ;
- PRINTF4 ((" "ID" : "ID" "ID" ", INDEX (k), INDEX (i), INDEX (j))) ;
+ PRINTF4 ((" " ID " : " ID " " ID " ", INDEX (k), INDEX (i), INDEX (j))) ;
if (do_values && prl >= 4)
{
ASSIGN (t, Tx, Tz, k, split) ;
projects / dealii-svn.git / commitdiff