int main (void)
{
/* ====================================================================== */
/* input matrix A definition */
/* ====================================================================== */
int A [ALEN] = {
0, 1, 4, /* row indices of nonzeros in column 0 */
2, 4, /* row indices of nonzeros in column 1 */
0, 1, 2, 3, /* row indices of nonzeros in column 2 */
1, 3} ; /* row indices of nonzeros in column 3 */
int p [ ] = {
0, /* column 0 is in A [0..2] */
3, /* column 1 is in A [3..4] */
5, /* column 2 is in A [5..8] */
9, /* column 3 is in A [9..10] */
A_NNZ} ; /* number of nonzeros in A */
/* ====================================================================== */
/* input matrix B definition */
/* ====================================================================== */
int B [ ] = { /* Note: only strictly lower triangular part */
/* is included, since symamd ignores the */
/* diagonal and upper triangular part of B. */
1, /* row indices of nonzeros in column 0 */
2, 3, /* row indices of nonzeros in column 1 */
/* row indices of nonzeros in column 2 (none) */
4 /* row indices of nonzeros in column 3 */
} ; /* row indices of nonzeros in column 4 (none) */
int q [ ] = {
0, /* column 0 is in B [0] */
1, /* column 1 is in B [1..2] */
3, /* column 2 is empty */
3, /* column 3 is in B [3] */
4, /* column 4 is empty */
B_NNZ} ; /* number of nonzeros in strictly lower B */
/* ====================================================================== */
/* other variable definitions */
/* ====================================================================== */
int perm [B_N+1] ; /* note the size is N+1 */
int stats [CCOLAMD_STATS] ; /* for ccolamd and csymamd output statistics */
int row, col, pp, length, ok ;
/* ====================================================================== */
/* dump the input matrix A */
/* ====================================================================== */
printf ("ccolamd %d-by-%d input matrix:\n", A_NROW, A_NCOL) ;
for (col = 0 ; col < A_NCOL ; col++)
{
length = p [col+1] - p [col] ;
printf ("Column %d, with %d entries:\n", col, length) ;
for (pp = p [col] ; pp < p [col+1] ; pp++)
{
row = A [pp] ;
printf (" row %d\n", row) ;
}
}
/* ====================================================================== */
/* order the matrix. Note that this destroys A and overwrites p */
/* ====================================================================== */
ok = ccolamd (A_NROW, A_NCOL, ALEN, A, p, (double *) NULL, stats, NULL) ;
ccolamd_report (stats) ;
if (!ok)
{
printf ("ccolamd error!\n") ;
exit (1) ;
}
/* ====================================================================== */
/* print the column ordering */
/* ====================================================================== */
printf ("ccolamd column ordering:\n") ;
printf ("1st column: %d\n", p [0]) ;
printf ("2nd column: %d\n", p [1]) ;
printf ("3rd column: %d\n", p [2]) ;
printf ("4th column: %d\n", p [3]) ;
/* ====================================================================== */
/* dump the strictly lower triangular part of symmetric input matrix B */
/* ====================================================================== */
printf ("\n\ncsymamd %d-by-%d input matrix:\n", B_N, B_N) ;
printf ("Entries in strictly lower triangular part:\n") ;
for (col = 0 ; col < B_N ; col++)
{
length = q [col+1] - q [col] ;
printf ("Column %d, with %d entries:\n", col, length) ;
for (pp = q [col] ; pp < q [col+1] ; pp++)
{
row = B [pp] ;
printf (" row %d\n", row) ;
}
}
/* ====================================================================== */
/* order the matrix B. Note that this does not modify B or q. */
/* ====================================================================== */
ok = csymamd (B_N, B, q, perm, (double *) NULL, stats, &calloc, &free,
NULL, -1) ;
csymamd_report (stats) ;
if (!ok)
{
printf ("csymamd error!\n") ;
exit (1) ;
}
/* ====================================================================== */
/* print the symmetric ordering */
/* ====================================================================== */
printf ("csymamd column ordering:\n") ;
printf ("1st row/column: %d\n", perm [0]) ;
printf ("2nd row/column: %d\n", perm [1]) ;
printf ("3rd row/column: %d\n", perm [2]) ;
printf ("4th row/column: %d\n", perm [3]) ;
printf ("5th row/column: %d\n", perm [4]) ;
return (0) ;
}
int CHOLMOD(csymamd)
(
/* ---- input ---- */
cholmod_sparse *A, /* matrix to order */
/* ---- output --- */
Int *Cmember, /* size nrow. see cholmod_ccolamd.c for description */
Int *Perm, /* size A->nrow, output permutation */
/* --------------- */
cholmod_common *Common
)
{
double knobs [CCOLAMD_KNOBS] ;
Int *perm, *Head ;
Int ok, i, nrow, stats [CCOLAMD_STATS] ;
/* ---------------------------------------------------------------------- */
/* check inputs */
/* ---------------------------------------------------------------------- */
RETURN_IF_NULL_COMMON (FALSE) ;
RETURN_IF_NULL (A, FALSE) ;
RETURN_IF_NULL (Perm, FALSE) ;
RETURN_IF_XTYPE_INVALID (A, CHOLMOD_PATTERN, CHOLMOD_ZOMPLEX, FALSE) ;
Common->status = CHOLMOD_OK ;
if (A->nrow != A->ncol || !(A->packed))
{
ERROR (CHOLMOD_INVALID, "matrix must be square and packed") ;
return (FALSE) ;
}
/* ---------------------------------------------------------------------- */
/* get inputs */
/* ---------------------------------------------------------------------- */
nrow = A->nrow ;
/* ---------------------------------------------------------------------- */
/* allocate workspace */
/* ---------------------------------------------------------------------- */
CHOLMOD(allocate_work) (nrow, 0, 0, Common) ;
if (Common->status < CHOLMOD_OK)
{
return (FALSE) ;
}
/* ---------------------------------------------------------------------- */
/* order the matrix (does not affect A->p or A->i) */
/* ---------------------------------------------------------------------- */
perm = Common->Head ; /* size nrow+1 (i/l/l) */
/* get parameters */
#ifdef LONG
ccolamd_l_set_defaults (knobs) ;
#else
ccolamd_set_defaults (knobs) ;
#endif
if (Common->current >= 0 && Common->current < CHOLMOD_MAXMETHODS)
{
/* get the knobs from the Common parameters */
knobs [CCOLAMD_DENSE_ROW] =Common->method[Common->current].prune_dense ;
knobs [CCOLAMD_AGGRESSIVE]=Common->method[Common->current].aggressive ;
}
{
#ifdef LONG
csymamd_l (nrow, A->i, A->p, perm, knobs, stats, Common->calloc_memory,
Common->free_memory, Cmember, A->stype) ;
#else
csymamd (nrow, A->i, A->p, perm, knobs, stats, Common->calloc_memory,
Common->free_memory, Cmember, A->stype) ;
#endif
ok = stats [CCOLAMD_STATUS] ;
}
if (ok == CCOLAMD_ERROR_out_of_memory)
{
ERROR (CHOLMOD_OUT_OF_MEMORY, "out of memory") ;
}
ok = (ok == CCOLAMD_OK || ok == CCOLAMD_OK_BUT_JUMBLED) ;
/* ---------------------------------------------------------------------- */
/* free the workspace and return result */
/* ---------------------------------------------------------------------- */
/* permutation returned in perm [0..n-1] */
for (i = 0 ; i < nrow ; i++)
{
Perm [i] = perm [i] ;
}
/* clear Head workspace (used for perm, in csymamd): */
Head = Common->Head ;
for (i = 0 ; i <= nrow ; i++)
{
Head [i] = EMPTY ;
}
return (ok) ;
}
