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) ;
}
static int ccolamd_interface
(
cholmod_sparse *A,
size_t alen,
Int *Perm,
Int *Cmember,
Int *fset,
Int fsize,
cholmod_sparse *C,
cholmod_common *Common
)
{
double knobs [CCOLAMD_KNOBS] ;
Int *Cp = NULL ;
Int ok, k, nrow, ncol, stats [CCOLAMD_STATS] ;
nrow = A->nrow ;
ncol = A->ncol ;
/* ---------------------------------------------------------------------- */
/* copy (and transpose) the input matrix A into the ccolamd workspace */
/* ---------------------------------------------------------------------- */
/* C = A (:,f)', which also packs A if needed. */
/* workspace: Iwork (nrow if no fset; MAX (nrow,ncol) if fset non-NULL) */
ok = CHOLMOD(transpose_unsym) (A, 0, NULL, fset, fsize, C, Common) ;
/* ---------------------------------------------------------------------- */
/* order the matrix (destroys the contents of C->i and C->p) */
/* ---------------------------------------------------------------------- */
/* get parameters */
#ifdef LONG
ccolamd_l_set_defaults (knobs) ;
#else
ccolamd_set_defaults (knobs) ;
#endif
if (Common->current < 0 || Common->current >= CHOLMOD_MAXMETHODS)
{
/* this is the CHOLMOD default, not the CCOLAMD default */
knobs [CCOLAMD_DENSE_ROW] = -1 ;
}
else
{
/* get the knobs from the Common parameters */
knobs [CCOLAMD_DENSE_COL] =Common->method[Common->current].prune_dense ;
knobs [CCOLAMD_DENSE_ROW] =Common->method[Common->current].prune_dense2;
knobs [CCOLAMD_AGGRESSIVE]=Common->method[Common->current].aggressive ;
knobs [CCOLAMD_LU] =Common->method[Common->current].order_for_lu;
}
if (ok)
{
#ifdef LONG
ccolamd_l (ncol, nrow, alen, C->i, C->p, knobs, stats, Cmember) ;
#else
ccolamd (ncol, nrow, alen, C->i, C->p, knobs, stats, Cmember) ;
#endif
ok = stats [CCOLAMD_STATUS] ;
ok = (ok == CCOLAMD_OK || ok == CCOLAMD_OK_BUT_JUMBLED) ;
/* permutation returned in C->p, if the ordering succeeded */
Cp = C->p ;
for (k = 0 ; k < nrow ; k++)
{
Perm [k] = Cp [k] ;
}
}
return (ok) ;
}
/* ************************************************************************* */
Ordering Ordering::ColamdConstrained(const VariableIndex& variableIndex,
std::vector<int>& cmember) {
gttic(Ordering_COLAMDConstrained);
gttic(Prepare);
const size_t nEntries = variableIndex.nEntries(), nFactors =
variableIndex.nFactors(), nVars = variableIndex.size();
// Convert to compressed column major format colamd wants it in (== MATLAB format!)
const size_t Alen = ccolamd_recommended((int) nEntries, (int) nFactors,
(int) nVars); /* colamd arg 3: size of the array A */
vector<int> A = vector<int>(Alen); /* colamd arg 4: row indices of A, of size Alen */
vector<int> p = vector<int>(nVars + 1); /* colamd arg 5: column pointers of A, of size n_col+1 */
// Fill in input data for COLAMD
p[0] = 0;
int count = 0;
vector<Key> keys(nVars); // Array to store the keys in the order we add them so we can retrieve them in permuted order
size_t index = 0;
for (auto key_factors: variableIndex) {
// Arrange factor indices into COLAMD format
const VariableIndex::Factors& column = key_factors.second;
for(size_t factorIndex: column) {
A[count++] = (int) factorIndex; // copy sparse column
}
p[index + 1] = count; // column j (base 1) goes from A[j-1] to A[j]-1
// Store key in array and increment index
keys[index] = key_factors.first;
++index;
}
assert((size_t)count == variableIndex.nEntries());
//double* knobs = NULL; /* colamd arg 6: parameters (uses defaults if NULL) */
double knobs[CCOLAMD_KNOBS];
ccolamd_set_defaults(knobs);
knobs[CCOLAMD_DENSE_ROW] = -1;
knobs[CCOLAMD_DENSE_COL] = -1;
int stats[CCOLAMD_STATS]; /* colamd arg 7: colamd output statistics and error codes */
gttoc(Prepare);
// call colamd, result will be in p
/* returns (1) if successful, (0) otherwise*/
if (nVars > 0) {
gttic(ccolamd);
int rv = ccolamd((int) nFactors, (int) nVars, (int) Alen, &A[0], &p[0],
knobs, stats, &cmember[0]);
if (rv != 1)
throw runtime_error(
(boost::format("ccolamd failed with return value %1%") % rv).str());
}
// ccolamd_report(stats);
// Convert elimination ordering in p to an ordering
gttic(Fill_Ordering);
Ordering result;
result.resize(nVars);
for (size_t j = 0; j < nVars; ++j)
result[j] = keys[p[j]];
gttoc(Fill_Ordering);
return result;
}
