std::string
print_bound( std::string const& name, std::string const& format ="xxx" )
{
std::stringstream ss;
ss << "<tr>";
ss << "<td>"+ name + "</td>";
ss << "<td>"+ format + "</td>";
ss << "<td class=\"table_divider\"></td>";
ss << print_triplet( color_model::bound_type::minimum(0), color_model::bound_type::maximum(0), color_model::bound_type::range(0) );
ss << "<td class=\"table_divider\"></td>";
ss << print_triplet( color_model::bound_type::minimum(1), color_model::bound_type::maximum(1), color_model::bound_type::range(1) );
ss << "<td class=\"table_divider\"></td>";
ss << print_triplet( color_model::bound_type::minimum(2), color_model::bound_type::maximum(2), color_model::bound_type::range(2) );
ss << "<tr>";
return ss.str();
}
int CHOLMOD(write_sparse)
(
/* ---- input ---- */
FILE *f, /* file to write to, must already be open */
cholmod_sparse *A, /* matrix to print */
cholmod_sparse *Z, /* optional matrix with pattern of explicit zeros */
char *comments, /* optional filename of comments to include */
/* --------------- */
cholmod_common *Common
)
{
double x, z ;
double *Ax, *Az ;
Int *Ap, *Ai, *Anz, *Zp, *Zi, *Znz ;
Int nrow, ncol, is_complex, symmetry, i, j, q, iz, p, nz, is_binary, stype,
is_integer, asym, is_sym, xtype, apacked, zpacked, pend, qend, k, zsym ;
int ok ;
/* ---------------------------------------------------------------------- */
/* check inputs */
/* ---------------------------------------------------------------------- */
RETURN_IF_NULL_COMMON (EMPTY) ;
RETURN_IF_NULL (f, EMPTY) ;
RETURN_IF_NULL (A, EMPTY) ;
RETURN_IF_XTYPE_INVALID (A, CHOLMOD_PATTERN, CHOLMOD_ZOMPLEX, EMPTY) ;
if (Z != NULL && (Z->nrow == 0 || Z->ncol == 0))
{
/* Z is non-NULL but empty, so treat it as a NULL matrix */
Z = NULL ;
}
if (Z != NULL)
{
RETURN_IF_XTYPE_INVALID (Z, CHOLMOD_PATTERN, CHOLMOD_ZOMPLEX, EMPTY) ;
if (Z->nrow != A->nrow || Z->ncol != A->ncol || Z->stype != A->stype)
{
ERROR (CHOLMOD_INVALID, "dimension or type of A and Z mismatch") ;
return (EMPTY) ;
}
}
Common->status = CHOLMOD_OK ;
/* ---------------------------------------------------------------------- */
/* get the A matrix */
/* ---------------------------------------------------------------------- */
Ap = A->p ;
Ai = A->i ;
Ax = A->x ;
Az = A->z ;
Anz = A->nz ;
nrow = A->nrow ;
ncol = A->ncol ;
xtype = A->xtype ;
apacked = A->packed ;
if (xtype == CHOLMOD_PATTERN)
{
/* a CHOLMOD pattern matrix is printed as "pattern" in the file */
is_binary = TRUE ;
is_integer = FALSE ;
is_complex = FALSE ;
}
else if (xtype == CHOLMOD_REAL)
{
/* determine if a real matrix is in fact binary or integer */
is_binary = TRUE ;
is_integer = TRUE ;
is_complex = FALSE ;
for (j = 0 ; (is_binary || is_integer) && j < ncol ; j++)
{
p = Ap [j] ;
pend = (apacked) ? Ap [j+1] : p + Anz [j] ;
for ( ; (is_binary || is_integer) && p < pend ; p++)
{
x = Ax [p] ;
if (x != 1)
{
is_binary = FALSE ;
}
/* convert to Int and then back to double */
i = (Int) x ;
z = (double) i ;
if (z != x)
{
is_integer = FALSE ;
}
}
}
}
else
{
/* a CHOLMOD complex matrix is printed as "complex" in the file */
is_binary = FALSE ;
is_integer = FALSE ;
is_complex = TRUE ;
}
/* ---------------------------------------------------------------------- */
/* get the Z matrix (only consider the pattern) */
/* ---------------------------------------------------------------------- */
Zp = NULL ;
Zi = NULL ;
Znz = NULL ;
zpacked = TRUE ;
if (Z != NULL)
{
Zp = Z->p ;
Zi = Z->i ;
Znz = Z->nz ;
zpacked = Z->packed ;
}
/* ---------------------------------------------------------------------- */
/* determine the symmetry of A and Z */
/* ---------------------------------------------------------------------- */
stype = A->stype ;
if (A->nrow != A->ncol)
{
asym = CHOLMOD_MM_RECTANGULAR ;
}
else if (stype != 0)
{
/* CHOLMOD's A and Z matrices have a symmetric (and matching) stype.
* Note that the diagonal is not checked. */
asym = is_complex ? CHOLMOD_MM_HERMITIAN : CHOLMOD_MM_SYMMETRIC ;
}
else if (!A->sorted)
{
/* A is in unsymmetric storage, but unsorted */
asym = CHOLMOD_MM_UNSYMMETRIC ;
}
else
{
/* CHOLMOD's stype is zero (stored in unsymmetric form) */
asym = EMPTY ;
zsym = EMPTY ;
#ifndef NMATRIXOPS
/* determine if the matrices are in fact symmetric or Hermitian */
asym = CHOLMOD(symmetry) (A, 1, NULL, NULL, NULL, NULL, Common) ;
zsym = (Z == NULL) ? 999 :
CHOLMOD(symmetry) (Z, 1, NULL, NULL, NULL, NULL, Common) ;
#endif
if (asym == EMPTY || zsym <= CHOLMOD_MM_UNSYMMETRIC)
{
/* not computed, out of memory, or Z is unsymmetric */
asym = CHOLMOD_MM_UNSYMMETRIC ;
}
}
/* ---------------------------------------------------------------------- */
/* write the Matrix Market header */
/* ---------------------------------------------------------------------- */
ok = fprintf (f, "%%%%MatrixMarket matrix coordinate") > 0 ;
if (is_complex)
{
ok = ok && (fprintf (f, " complex") > 0) ;
}
else if (is_binary)
{
ok = ok && (fprintf (f, " pattern") > 0) ;
}
else if (is_integer)
{
ok = ok && (fprintf (f, " integer") > 0) ;
}
else
{
ok = ok && (fprintf (f, " real") > 0) ;
}
switch (asym)
{
case CHOLMOD_MM_RECTANGULAR:
case CHOLMOD_MM_UNSYMMETRIC:
/* A is rectangular or unsymmetric */
ok = ok && (fprintf (f, " general\n") > 0) ;
is_sym = FALSE ;
symmetry = CHOLMOD_MM_UNSYMMETRIC ;
break ;
case CHOLMOD_MM_SYMMETRIC:
case CHOLMOD_MM_SYMMETRIC_POSDIAG:
/* A is symmetric */
ok = ok && (fprintf (f, " symmetric\n") > 0) ;
is_sym = TRUE ;
symmetry = CHOLMOD_MM_SYMMETRIC ;
break ;
case CHOLMOD_MM_HERMITIAN:
case CHOLMOD_MM_HERMITIAN_POSDIAG:
/* A is Hermitian */
ok = ok && (fprintf (f, " Hermitian\n") > 0) ;
is_sym = TRUE ;
symmetry = CHOLMOD_MM_HERMITIAN ;
break ;
case CHOLMOD_MM_SKEW_SYMMETRIC:
/* A is skew symmetric */
ok = ok && (fprintf (f, " skew-symmetric\n") > 0) ;
is_sym = TRUE ;
symmetry = CHOLMOD_MM_SKEW_SYMMETRIC ;
break ;
}
/* ---------------------------------------------------------------------- */
/* include the comments if present */
/* ---------------------------------------------------------------------- */
ok = ok && include_comments (f, comments) ;
/* ---------------------------------------------------------------------- */
/* write a sparse matrix (A and Z) */
/* ---------------------------------------------------------------------- */
nz = ntriplets (A, is_sym) + ntriplets (Z, is_sym) ;
/* write the first data line, with nrow, ncol, and # of triplets */
ok = ok && (fprintf (f, ID " " ID " " ID "\n", nrow, ncol, nz) > 0) ;
for (j = 0 ; ok && j < ncol ; j++)
{
/* merge column of A and Z */
p = Ap [j] ;
pend = (apacked) ? Ap [j+1] : p + Anz [j] ;
q = (Z == NULL) ? 0 : Zp [j] ;
qend = (Z == NULL) ? 0 : ((zpacked) ? Zp [j+1] : q + Znz [j]) ;
while (ok)
{
/* get the next row index from A and Z */
i = (p < pend) ? Ai [p] : (nrow+1) ;
iz = (q < qend) ? Zi [q] : (nrow+2) ;
if (i <= iz)
{
/* get A(i,j), or quit if both A and Z are exhausted */
if (i == nrow+1) break ;
get_value (Ax, Az, p, xtype, &x, &z) ;
p++ ;
}
else
{
/* get Z(i,j) */
i = iz ;
x = 0 ;
z = 0 ;
q++ ;
}
if ((stype < 0 && i >= j) || (stype == 0 && (i >= j || !is_sym)))
{
/* CHOLMOD matrix is symmetric-lower (and so is the file);
* or CHOLMOD matrix is unsymmetric and either A(i,j) is in
* the lower part or the file is unsymmetric. */
ok = ok && print_triplet (f, is_binary, is_complex, is_integer,
i,j, x,z) ;
}
else if (stype > 0 && i <= j)
{
/* CHOLMOD matrix is symmetric-upper, but the file is
* symmetric-lower. Need to transpose the entry. If the
* matrix is real, the complex part is ignored. If the matrix
* is complex, it Hermitian.
*/
ASSERT (IMPLIES (is_complex, asym == CHOLMOD_MM_HERMITIAN)) ;
if (z != 0)
{
z = -z ;
}
ok = ok && print_triplet (f, is_binary, is_complex, is_integer,
j,i, x,z) ;
}
}
}
if (!ok)
{
ERROR (CHOLMOD_INVALID, "error reading/writing file") ;
return (EMPTY) ;
}
return (asym) ;
}
