colamd.h File Reference

#include <stdlib.h>

Include dependency graph for colamd.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	mbdyn_Colamd_Col
struct	mbdyn_Colamd_Row

Macros
#define	COLAMD_KNOBS   20
#define	COLAMD_STATS   20
#define	COLAMD_DENSE_ROW   0
#define	COLAMD_DENSE_COL   1
#define	COLAMD_DEFRAG_COUNT   2
#define	COLAMD_STATUS   3
#define	COLAMD_INFO1   4
#define	COLAMD_INFO2   5
#define	COLAMD_INFO3   6
#define	COLAMD_OK   (0)
#define	COLAMD_OK_BUT_JUMBLED   (1)
#define	COLAMD_ERROR_A_not_present   (-1)
#define	COLAMD_ERROR_p_not_present   (-2)
#define	COLAMD_ERROR_nrow_negative   (-3)
#define	COLAMD_ERROR_ncol_negative   (-4)
#define	COLAMD_ERROR_nnz_negative   (-5)
#define	COLAMD_ERROR_p0_nonzero   (-6)
#define	COLAMD_ERROR_A_too_small   (-7)
#define	COLAMD_ERROR_col_length_negative   (-8)
#define	COLAMD_ERROR_row_index_out_of_bounds   (-9)
#define	COLAMD_ERROR_out_of_memory   (-10)
#define	COLAMD_ERROR_internal_error   (-999)
#define	COLAMD_C(n_col)   (((n_col) + 1) * sizeof (mbdyn_Colamd_Col) / sizeof (int))
#define	COLAMD_R(n_row)   (((n_row) + 1) * sizeof (mbdyn_Colamd_Row) / sizeof (int))
#define	COLAMD_RECOMMENDED(nnz, n_row, n_col)

Typedefs
typedef struct mbdyn_Colamd_Col	mbdyn_Colamd_Col
typedef struct mbdyn_Colamd_Row	mbdyn_Colamd_Row

Functions
integer	mbdyn_colamd_recommended (integer nnz, integer n_row, integer n_col)
void	mbdyn_colamd_set_defaults (double knobs[20])
integer	mbdyn_colamd (integer n_row, integer n_col, integer Alen, integer A[], integer p[], double knobs[20], integer stats[20])
integer	mbdyn_symamd (integer n, integer A[], integer p[], integer perm[], double knobs[20], integer stats[20], void *(*allocate)(size_t, size_t), void(*release)(void *))
void	mbdyn_colamd_report (integer stats[20])
void	mbdyn_symamd_report (integer stats[20])

Macro Definition Documentation

#define COLAMD_C

(

n_col

)

(((n_col) + 1) * sizeof (mbdyn_Colamd_Col) / sizeof (int))

Definition at line 225 of file colamd.h.

Referenced by mbdyn_colamd().

#define COLAMD_DEFRAG_COUNT   2

Definition at line 126 of file colamd.h.

Referenced by mbdyn_colamd(), mbdyn_symamd(), and print_report().

#define COLAMD_DENSE_COL   1

Definition at line 123 of file colamd.h.

Referenced by init_scoring(), mbdyn_colamd(), mbdyn_colamd_set_defaults(), mbdyn_symamd(), and print_report().

#define COLAMD_DENSE_ROW   0

Definition at line 120 of file colamd.h.

Referenced by init_scoring(), mbdyn_colamd(), mbdyn_colamd_set_defaults(), mbdyn_symamd(), and print_report().

#define COLAMD_ERROR_A_not_present   (-1)

Definition at line 139 of file colamd.h.

Referenced by mbdyn_colamd(), mbdyn_symamd(), and print_report().

#define COLAMD_ERROR_A_too_small   (-7)

Definition at line 145 of file colamd.h.

Referenced by mbdyn_colamd(), and print_report().

#define COLAMD_ERROR_col_length_negative   (-8)

Definition at line 146 of file colamd.h.

Referenced by init_rows_cols(), mbdyn_symamd(), and print_report().

#define COLAMD_ERROR_internal_error   (-999)

Definition at line 149 of file colamd.h.

Referenced by mbdyn_symamd(), and print_report().

#define COLAMD_ERROR_ncol_negative   (-4)

Definition at line 142 of file colamd.h.

Referenced by mbdyn_colamd(), mbdyn_symamd(), and print_report().

#define COLAMD_ERROR_nnz_negative   (-5)

Definition at line 143 of file colamd.h.

Referenced by mbdyn_colamd(), mbdyn_symamd(), and print_report().

#define COLAMD_ERROR_nrow_negative   (-3)

Definition at line 141 of file colamd.h.

Referenced by mbdyn_colamd(), and print_report().

#define COLAMD_ERROR_out_of_memory   (-10)

Definition at line 148 of file colamd.h.

Referenced by mbdyn_symamd(), and print_report().

#define COLAMD_ERROR_p0_nonzero   (-6)

Definition at line 144 of file colamd.h.

Referenced by mbdyn_colamd(), mbdyn_symamd(), and print_report().

#define COLAMD_ERROR_p_not_present   (-2)

Definition at line 140 of file colamd.h.

Referenced by mbdyn_colamd(), mbdyn_symamd(), and print_report().

#define COLAMD_ERROR_row_index_out_of_bounds   (-9)

Definition at line 147 of file colamd.h.

Referenced by init_rows_cols(), mbdyn_symamd(), and print_report().

#define COLAMD_INFO1   4

Definition at line 132 of file colamd.h.

Referenced by init_rows_cols(), mbdyn_colamd(), mbdyn_symamd(), and print_report().

#define COLAMD_INFO2   5

Definition at line 133 of file colamd.h.

Referenced by init_rows_cols(), mbdyn_colamd(), mbdyn_symamd(), and print_report().

#define COLAMD_INFO3   6

Definition at line 134 of file colamd.h.

Referenced by init_rows_cols(), mbdyn_symamd(), and print_report().

#define COLAMD_KNOBS   20

Definition at line 114 of file colamd.h.

Referenced by NaiveSparsePermSolutionManager< T >::ComputePermutation(), mbdyn_colamd(), mbdyn_colamd_set_defaults(), and mbdyn_symamd().

#define COLAMD_OK   (0)

Definition at line 137 of file colamd.h.

Referenced by mbdyn_colamd(), mbdyn_symamd(), and print_report().

#define COLAMD_OK_BUT_JUMBLED   (1)

Definition at line 138 of file colamd.h.

Referenced by init_rows_cols(), mbdyn_symamd(), and print_report().

#define COLAMD_R

(

n_row

)

(((n_row) + 1) * sizeof (mbdyn_Colamd_Row) / sizeof (int))

Definition at line 226 of file colamd.h.

Referenced by mbdyn_colamd().

#define COLAMD_RECOMMENDED	(		nnz,
			n_row,
			n_col
	)

Value:

(                                                                             \
((nnz) < 0 || (n_row) < 0 || (n_col) < 0)                                     \
?                                                                             \
    (-1)                                                                      \
:                                                                             \
    (2 * (nnz) + COLAMD_C (n_col) + COLAMD_R (n_row) + (n_col) + ((nnz) / 5)) \
)

Definition at line 228 of file colamd.h.

Referenced by mbdyn_colamd_recommended().

#define COLAMD_STATS   20

Definition at line 117 of file colamd.h.

Referenced by NaiveSparsePermSolutionManager< T >::ComputePermutation(), mbdyn_colamd(), and mbdyn_symamd().

#define COLAMD_STATUS   3

Definition at line 129 of file colamd.h.

Referenced by init_rows_cols(), mbdyn_colamd(), mbdyn_symamd(), and print_report().

Typedef Documentation

typedef struct mbdyn_Colamd_Col mbdyn_Colamd_Col

typedef struct mbdyn_Colamd_Row mbdyn_Colamd_Row

Function Documentation

integer mbdyn_colamd	(	integer	n_row,
		integer	n_col,
		integer	Alen,
		integer	A[],
		integer	p[],
		double	knobs[20],
		integer	stats[20]
	)

Definition at line 1411 of file colamd.c.

References COLAMD_C, COLAMD_DEFRAG_COUNT, COLAMD_DENSE_COL, COLAMD_DENSE_ROW, COLAMD_ERROR_A_not_present, COLAMD_ERROR_A_too_small, COLAMD_ERROR_ncol_negative, COLAMD_ERROR_nnz_negative, COLAMD_ERROR_nrow_negative, COLAMD_ERROR_p0_nonzero, COLAMD_ERROR_p_not_present, COLAMD_INFO1, COLAMD_INFO2, COLAMD_KNOBS, COLAMD_OK, COLAMD_R, COLAMD_STATS, COLAMD_STATUS, DEBUG0, FALSE, find_ordering(), init_rows_cols(), init_scoring(), mbdyn_colamd_set_defaults(), order_children(), and TRUE.

Referenced by NaiveSparsePermSolutionManager< T >::ComputePermutation(), and mbdyn_symamd().

{
    /* === Local variables ================================================== */

    integer i ;                 /* loop index */
    integer nnz ;                       /* nonzeros in A */
    integer Row_size ;          /* size of Row [], in integers */
    integer Col_size ;          /* size of Col [], in integers */
    integer need ;                      /* minimum required length of A */
    mbdyn_Colamd_Row *Row ;             /* pointer into A of Row [0..n_row] array */
    mbdyn_Colamd_Col *Col ;             /* pointer into A of Col [0..n_col] array */
    integer n_col2 ;            /* number of non-dense, non-empty columns */
    integer n_row2 ;            /* number of non-dense, non-empty rows */
    integer ngarbage ;          /* number of garbage collections performed */
    integer max_deg ;           /* maximum row degree */
    double default_knobs [COLAMD_KNOBS] ;       /* default knobs array */

#ifndef NDEBUG
    colamd_get_debug ("colamd") ;
#endif /* NDEBUG */

    /* === Check the input arguments ======================================== */

    if (!stats)
    {
        DEBUG0 (("colamd: stats not present\n")) ;
        return (FALSE) ;
    }
    for (i = 0 ; i < COLAMD_STATS ; i++)
    {
        stats [i] = 0 ;
    }
    stats [COLAMD_STATUS] = COLAMD_OK ;
    stats [COLAMD_INFO1] = -1 ;
    stats [COLAMD_INFO2] = -1 ;

    if (!A)             /* A is not present */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_A_not_present ;
        DEBUG0 (("colamd: A not present\n")) ;
        return (FALSE) ;
    }

    if (!p)             /* p is not present */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_p_not_present ;
        DEBUG0 (("colamd: p not present\n")) ;
        return (FALSE) ;
    }

    if (n_row < 0)      /* n_row must be >= 0 */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_nrow_negative ;
        stats [COLAMD_INFO1] = n_row ;
        DEBUG0 (("colamd: nrow negative %d\n", n_row)) ;
        return (FALSE) ;
    }

    if (n_col < 0)      /* n_col must be >= 0 */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_ncol_negative ;
        stats [COLAMD_INFO1] = n_col ;
        DEBUG0 (("colamd: ncol negative %d\n", n_col)) ;
        return (FALSE) ;
    }

    nnz = p [n_col] ;
    if (nnz < 0)        /* nnz must be >= 0 */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_nnz_negative ;
        stats [COLAMD_INFO1] = nnz ;
        DEBUG0 (("colamd: number of entries negative %d\n", nnz)) ;
        return (FALSE) ;
    }

    if (p [0] != 0)
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_p0_nonzero ;
        stats [COLAMD_INFO1] = p [0] ;
        DEBUG0 (("colamd: p[0] not zero %d\n", p [0])) ;
        return (FALSE) ;
    }

    /* === If no knobs, set default knobs =================================== */

    if (!knobs)
    {
        mbdyn_colamd_set_defaults (default_knobs) ;
        knobs = default_knobs ;
    }

    /* === Allocate the Row and Col arrays from array A ===================== */

    Col_size = COLAMD_C (n_col) ;
    Row_size = COLAMD_R (n_row) ;
    need = 2*nnz + n_col + Col_size + Row_size ;

    if (need > Alen)
    {
        /* not enough space in array A to perform the ordering */
        stats [COLAMD_STATUS] = COLAMD_ERROR_A_too_small ;
        stats [COLAMD_INFO1] = need ;
        stats [COLAMD_INFO2] = Alen ;
        DEBUG0 (("colamd: Need Alen >= %d, given only Alen = %d\n", need,Alen));
        return (FALSE) ;
    }

    Alen -= Col_size + Row_size ;
    Col = (mbdyn_Colamd_Col *) &A [Alen] ;
    Row = (mbdyn_Colamd_Row *) &A [Alen + Col_size] ;

    /* === Construct the row and column data structures ===================== */

    if (!init_rows_cols (n_row, n_col, Row, Col, A, p, stats))
    {
        /* input matrix is invalid */
        DEBUG0 (("colamd: Matrix invalid\n")) ;
        return (FALSE) ;
    }

    /* === Initialize scores, kill dense rows/columns ======================= */

    init_scoring (n_row, n_col, Row, Col, A, p, knobs,
        &n_row2, &n_col2, &max_deg) ;

    /* === Order the supercolumns =========================================== */

    ngarbage = find_ordering (n_row, n_col, Alen, Row, Col, A, p,
        n_col2, max_deg, 2*nnz) ;

    /* === Order the non-principal columns ================================== */

    order_children (n_col, Col, p) ;

    /* === Return statistics in stats ======================================= */

    stats [COLAMD_DENSE_ROW] = n_row - n_row2 ;
    stats [COLAMD_DENSE_COL] = n_col - n_col2 ;
    stats [COLAMD_DEFRAG_COUNT] = ngarbage ;
    DEBUG0 (("colamd: done.\n")) ; 
    return (TRUE) ;
}

Here is the call graph for this function:

integer mbdyn_colamd_recommended	(	integer	nnz,
		integer	n_row,
		integer	n_col
	)

Definition at line 1004 of file colamd.c.

References COLAMD_RECOMMENDED.

Referenced by NaiveSparsePermSolutionManager< T >::ComputePermutation(), and mbdyn_symamd().

{
    return (COLAMD_RECOMMENDED (nnz, n_row, n_col)) ; 
}

void mbdyn_colamd_report

(

integer

stats[20]

)

Definition at line 1570 of file colamd.c.

References print_report().

{
    print_report ("colamd", stats) ;
}

Here is the call graph for this function:

void mbdyn_colamd_set_defaults

(

double

knobs[20]

)

Definition at line 1038 of file colamd.c.

References COLAMD_DENSE_COL, COLAMD_DENSE_ROW, and COLAMD_KNOBS.

Referenced by NaiveSparsePermSolutionManager< T >::ComputePermutation(), mbdyn_colamd(), and mbdyn_symamd().

{
    /* === Local variables ================================================== */

    integer i ;

    if (!knobs)
    {
        return ;                        /* no knobs to initialize */
    }
    for (i = 0 ; i < COLAMD_KNOBS ; i++)
    {
        knobs [i] = 0 ;
    }
    knobs [COLAMD_DENSE_ROW] = 0.5 ;    /* ignore rows over 50% dense */
    knobs [COLAMD_DENSE_COL] = 0.5 ;    /* ignore columns over 50% dense */
}

integer mbdyn_symamd	(	integer	n,
		integer	A[],
		integer	p[],
		integer	perm[],
		double	knobs[20],
		integer	stats[20],
		void *(*)(size_t, size_t)	allocate,
		void(*)(void *)	release
	)

Definition at line 1066 of file colamd.c.

References ASSERT, COLAMD_DEFRAG_COUNT, COLAMD_DENSE_COL, COLAMD_DENSE_ROW, COLAMD_ERROR_A_not_present, COLAMD_ERROR_col_length_negative, COLAMD_ERROR_internal_error, COLAMD_ERROR_ncol_negative, COLAMD_ERROR_nnz_negative, COLAMD_ERROR_out_of_memory, COLAMD_ERROR_p0_nonzero, COLAMD_ERROR_p_not_present, COLAMD_ERROR_row_index_out_of_bounds, COLAMD_INFO1, COLAMD_INFO2, COLAMD_INFO3, COLAMD_KNOBS, COLAMD_OK, COLAMD_OK_BUT_JUMBLED, COLAMD_STATS, COLAMD_STATUS, count, DEBUG0, DEBUG1, FALSE, mbdyn_colamd(), mbdyn_colamd_recommended(), mbdyn_colamd_set_defaults(), and TRUE.

{
    /* === Local variables ================================================== */

    integer *count ;            /* length of each column of M, and col pointer*/
    integer *mark ;                     /* mark array for finding duplicate entries */
    integer *M ;                        /* row indices of matrix M */
    integer Mlen ;                      /* length of M */
    integer n_row ;                     /* number of rows in M */
    integer nnz ;                       /* number of entries in A */
    integer i ;                 /* row index of A */
    integer j ;                 /* column index of A */
    integer k ;                 /* row index of M */ 
    integer mnz ;                       /* number of nonzeros in M */
    integer pp ;                        /* index into a column of A */
    integer last_row ;          /* last row seen in the current column */
    integer length ;            /* number of nonzeros in a column */

    double cknobs [COLAMD_KNOBS] ;              /* knobs for colamd */
    double default_knobs [COLAMD_KNOBS] ;       /* default knobs for colamd */
    integer cstats [COLAMD_STATS] ;                     /* colamd stats */

#ifndef NDEBUG
    colamd_get_debug ("symamd") ;
#endif /* NDEBUG */

    /* === Check the input arguments ======================================== */

    if (!stats)
    {
        DEBUG0 (("symamd: stats not present\n")) ;
        return (FALSE) ;
    }
    for (i = 0 ; i < COLAMD_STATS ; i++)
    {
        stats [i] = 0 ;
    }
    stats [COLAMD_STATUS] = COLAMD_OK ;
    stats [COLAMD_INFO1] = -1 ;
    stats [COLAMD_INFO2] = -1 ;

    if (!A)
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_A_not_present ;
        DEBUG0 (("symamd: A not present\n")) ;
        return (FALSE) ;
    }

    if (!p)             /* p is not present */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_p_not_present ;
        DEBUG0 (("symamd: p not present\n")) ;
        return (FALSE) ;
    }

    if (n < 0)          /* n must be >= 0 */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_ncol_negative ;
        stats [COLAMD_INFO1] = n ;
        DEBUG0 (("symamd: n negative %d\n", n)) ;
        return (FALSE) ;
    }

    nnz = p [n] ;
    if (nnz < 0)        /* nnz must be >= 0 */
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_nnz_negative ;
        stats [COLAMD_INFO1] = nnz ;
        DEBUG0 (("symamd: number of entries negative %d\n", nnz)) ;
        return (FALSE) ;
    }

    if (p [0] != 0)
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_p0_nonzero ;
        stats [COLAMD_INFO1] = p [0] ;
        DEBUG0 (("symamd: p[0] not zero %d\n", p [0])) ;
        return (FALSE) ;
    }

    /* === If no knobs, set default knobs =================================== */

    if (!knobs)
    {
        mbdyn_colamd_set_defaults (default_knobs) ;
        knobs = default_knobs ;
    }

    /* === Allocate count and mark ========================================== */

    count = (integer *) ((*allocate) (n+1, sizeof (int))) ;
    if (!count)
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_out_of_memory ;
        DEBUG0 (("symamd: allocate count (size %d) failed\n", n+1)) ;
        return (FALSE) ;
    }

    mark = (integer *) ((*allocate) (n+1, sizeof (int))) ;
    if (!mark)
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_out_of_memory ;
        (*release) ((void *) count) ;
        DEBUG0 (("symamd: allocate mark (size %d) failed\n", n+1)) ;
        return (FALSE) ;
    }

    /* === Compute column counts of M, check if A is valid ================== */

    stats [COLAMD_INFO3] = 0 ;  /* number of duplicate or unsorted row indices*/

    for (i = 0 ; i < n ; i++)
    {
        mark [i] = -1 ;
    }

    for (j = 0 ; j < n ; j++)
    {
        last_row = -1 ;

        length = p [j+1] - p [j] ;
        if (length < 0)
        {
            /* column pointers must be non-decreasing */
            stats [COLAMD_STATUS] = COLAMD_ERROR_col_length_negative ;
            stats [COLAMD_INFO1] = j ;
            stats [COLAMD_INFO2] = length ;
            (*release) ((void *) count) ;
            (*release) ((void *) mark) ;
            DEBUG0 (("symamd: col %d negative length %d\n", j, length)) ;
            return (FALSE) ;
        }

        for (pp = p [j] ; pp < p [j+1] ; pp++)
        {
            i = A [pp] ;
            if (i < 0 || i >= n)
            {
                /* row index i, in column j, is out of bounds */
                stats [COLAMD_STATUS] = COLAMD_ERROR_row_index_out_of_bounds ;
                stats [COLAMD_INFO1] = j ;
                stats [COLAMD_INFO2] = i ;
                stats [COLAMD_INFO3] = n ;
                (*release) ((void *) count) ;
                (*release) ((void *) mark) ;
                DEBUG0 (("symamd: row %d col %d out of bounds\n", i, j)) ;
                return (FALSE) ;
            }

            if (i <= last_row || mark [i] == j)
            {
                /* row index is unsorted or repeated (or both), thus col */
                /* is jumbled.  This is a notice, not an error condition. */
                stats [COLAMD_STATUS] = COLAMD_OK_BUT_JUMBLED ;
                stats [COLAMD_INFO1] = j ;
                stats [COLAMD_INFO2] = i ;
                (stats [COLAMD_INFO3]) ++ ;
                DEBUG1 (("symamd: row %d col %d unsorted/duplicate\n", i, j)) ;
            }

            if (i > j && mark [i] != j)
            {
                /* row k of M will contain column indices i and j */
                count [i]++ ;
                count [j]++ ;
            }

            /* mark the row as having been seen in this column */
            mark [i] = j ;

            last_row = i ;
        }
    }

    if (stats [COLAMD_STATUS] == COLAMD_OK)
    {
        /* if there are no duplicate entries, then mark is no longer needed */
        (*release) ((void *) mark) ;
    }

    /* === Compute column pointers of M ===================================== */

    /* use output permutation, perm, for column pointers of M */
    perm [0] = 0 ;
    for (j = 1 ; j <= n ; j++)
    {
        perm [j] = perm [j-1] + count [j-1] ;
    }
    for (j = 0 ; j < n ; j++)
    {
        count [j] = perm [j] ;
    }

    /* === Construct M ====================================================== */

    mnz = perm [n] ;
    n_row = mnz / 2 ;
    Mlen = mbdyn_colamd_recommended (mnz, n_row, n) ;
    M = (integer *) ((*allocate) (Mlen, sizeof (int))) ;
    DEBUG0 (("symamd: M is %d-by-%d with %d entries, Mlen = %d\n",
        n_row, n, mnz, Mlen)) ;

    if (!M)
    {
        stats [COLAMD_STATUS] = COLAMD_ERROR_out_of_memory ;
        (*release) ((void *) count) ;
        (*release) ((void *) mark) ;
        DEBUG0 (("symamd: allocate M (size %d) failed\n", Mlen)) ;
        return (FALSE) ;
    }

    k = 0 ;

    if (stats [COLAMD_STATUS] == COLAMD_OK)
    {
        /* Matrix is OK */
        for (j = 0 ; j < n ; j++)
        {
            ASSERT (p [j+1] - p [j] >= 0) ;
            for (pp = p [j] ; pp < p [j+1] ; pp++)
            {
                i = A [pp] ;
                ASSERT (i >= 0 && i < n) ;
                if (i > j)
                {
                    /* row k of M contains column indices i and j */
                    M [count [i]++] = k ;
                    M [count [j]++] = k ;
                    k++ ;
                }
            }
        }
    }
    else
    {
        /* Matrix is jumbled.  Do not add duplicates to M.  Unsorted cols OK. */
        DEBUG0 (("symamd: Duplicates in A.\n")) ;
        for (i = 0 ; i < n ; i++)
        {
            mark [i] = -1 ;
        }
        for (j = 0 ; j < n ; j++)
        {
            ASSERT (p [j+1] - p [j] >= 0) ;
            for (pp = p [j] ; pp < p [j+1] ; pp++)
            {
                i = A [pp] ;
                ASSERT (i >= 0 && i < n) ;
                if (i > j && mark [i] != j)
                {
                    /* row k of M contains column indices i and j */
                    M [count [i]++] = k ;
                    M [count [j]++] = k ;
                    k++ ;
                    mark [i] = j ;
                }
            }
        }
        (*release) ((void *) mark) ;
    }

    /* count and mark no longer needed */
    (*release) ((void *) count) ;
    ASSERT (k == n_row) ;

    /* === Adjust the knobs for M =========================================== */

    for (i = 0 ; i < COLAMD_KNOBS ; i++)
    {
        cknobs [i] = knobs [i] ;
    }

    /* there are no dense rows in M */
    cknobs [COLAMD_DENSE_ROW] = 1.0 ;

    if (n_row != 0 && n < n_row)
    {
        /* On input, the knob is a fraction of 1..n, the number of rows of A. */
        /* Convert it to a fraction of 1..n_row, of the number of rows of M. */
        cknobs [COLAMD_DENSE_COL] = (knobs [COLAMD_DENSE_ROW] * n) / n_row ;
    }
    else
    {
        /* no dense columns in M */
        cknobs [COLAMD_DENSE_COL] = 1.0 ;
    }

    DEBUG0 (("symamd: dense col knob for M: %g\n", cknobs [COLAMD_DENSE_COL])) ;

    /* === Order the columns of M =========================================== */

    if (!mbdyn_colamd (n_row, n, Mlen, M, perm, cknobs, cstats))
    {
        /* This "cannot" happen, unless there is a bug in the code. */
        stats [COLAMD_STATUS] = COLAMD_ERROR_internal_error ;
        (*release) ((void *) M) ;
        DEBUG0 (("symamd: internal error!\n")) ;
        return (FALSE) ;
    }

    /* Note that the output permutation is now in perm */

    /* === get the statistics for symamd from colamd ======================== */

    /* note that a dense column in colamd means a dense row and col in symamd */
    stats [COLAMD_DENSE_ROW]    = cstats [COLAMD_DENSE_COL] ;
    stats [COLAMD_DENSE_COL]    = cstats [COLAMD_DENSE_COL] ;
    stats [COLAMD_DEFRAG_COUNT] = cstats [COLAMD_DEFRAG_COUNT] ;

    /* === Free M =========================================================== */

    (*release) ((void *) M) ;
    DEBUG0 (("symamd: done.\n")) ;
    return (TRUE) ;

}

Here is the call graph for this function:

void mbdyn_symamd_report

(

integer

stats[20]

)

Definition at line 1583 of file colamd.c.

References print_report().

{
    print_report ("symamd", stats) ;
}

Here is the call graph for this function: