419 lines
9.8 KiB
C
419 lines
9.8 KiB
C
/*! @file sp_coletree.c
|
|
* \brief Tree layout and computation routines
|
|
*
|
|
*<pre>
|
|
* -- SuperLU routine (version 3.1) --
|
|
* Univ. of California Berkeley, Xerox Palo Alto Research Center,
|
|
* and Lawrence Berkeley National Lab.
|
|
* August 1, 2008
|
|
*
|
|
* Copyright (c) 1994 by Xerox Corporation. All rights reserved.
|
|
*
|
|
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
|
|
* EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
|
*
|
|
* Permission is hereby granted to use or copy this program for any
|
|
* purpose, provided the above notices are retained on all copies.
|
|
* Permission to modify the code and to distribute modified code is
|
|
* granted, provided the above notices are retained, and a notice that
|
|
* the code was modified is included with the above copyright notice.
|
|
* </pre>
|
|
*/
|
|
|
|
/* Elimination tree computation and layout routines */
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include "slu_ddefs.h"
|
|
|
|
/*
|
|
* Implementation of disjoint set union routines.
|
|
* Elements are integers in 0..n-1, and the
|
|
* names of the sets themselves are of type int.
|
|
*
|
|
* Calls are:
|
|
* initialize_disjoint_sets (n) initial call.
|
|
* s = make_set (i) returns a set containing only i.
|
|
* s = link (t, u) returns s = t union u, destroying t and u.
|
|
* s = find (i) return name of set containing i.
|
|
* finalize_disjoint_sets final call.
|
|
*
|
|
* This implementation uses path compression but not weighted union.
|
|
* See Tarjan's book for details.
|
|
* John Gilbert, CMI, 1987.
|
|
*
|
|
* Implemented path-halving by XSL 07/05/95.
|
|
*/
|
|
|
|
|
|
static
|
|
int *mxCallocInt(int n)
|
|
{
|
|
register int i;
|
|
int *buf;
|
|
|
|
buf = (int *) SUPERLU_MALLOC( n * sizeof(int) );
|
|
if ( !buf ) {
|
|
ABORT("SUPERLU_MALLOC fails for buf in mxCallocInt()");
|
|
}
|
|
for (i = 0; i < n; i++) buf[i] = 0;
|
|
return (buf);
|
|
}
|
|
|
|
static
|
|
void initialize_disjoint_sets (
|
|
int n,
|
|
int **pp
|
|
)
|
|
{
|
|
(*pp) = mxCallocInt(n);
|
|
}
|
|
|
|
|
|
static
|
|
int make_set (
|
|
int i,
|
|
int *pp
|
|
)
|
|
{
|
|
pp[i] = i;
|
|
return i;
|
|
}
|
|
|
|
|
|
static
|
|
int link (
|
|
int s,
|
|
int t,
|
|
int *pp
|
|
)
|
|
{
|
|
pp[s] = t;
|
|
return t;
|
|
}
|
|
|
|
|
|
/* PATH HALVING */
|
|
static
|
|
int find (
|
|
int i,
|
|
int *pp
|
|
)
|
|
{
|
|
register int p, gp;
|
|
|
|
p = pp[i];
|
|
gp = pp[p];
|
|
while (gp != p) {
|
|
pp[i] = gp;
|
|
i = gp;
|
|
p = pp[i];
|
|
gp = pp[p];
|
|
}
|
|
return (p);
|
|
}
|
|
|
|
#if 0
|
|
/* PATH COMPRESSION */
|
|
static
|
|
int find (
|
|
int i
|
|
)
|
|
{
|
|
if (pp[i] != i)
|
|
pp[i] = find (pp[i]);
|
|
return pp[i];
|
|
}
|
|
#endif
|
|
|
|
static
|
|
void finalize_disjoint_sets (
|
|
int *pp
|
|
)
|
|
{
|
|
SUPERLU_FREE(pp);
|
|
}
|
|
|
|
|
|
/*
|
|
* Find the elimination tree for A'*A.
|
|
* This uses something similar to Liu's algorithm.
|
|
* It runs in time O(nz(A)*log n) and does not form A'*A.
|
|
*
|
|
* Input:
|
|
* Sparse matrix A. Numeric values are ignored, so any
|
|
* explicit zeros are treated as nonzero.
|
|
* Output:
|
|
* Integer array of parents representing the elimination
|
|
* tree of the symbolic product A'*A. Each vertex is a
|
|
* column of A, and nc means a root of the elimination forest.
|
|
*
|
|
* John R. Gilbert, Xerox, 10 Dec 1990
|
|
* Based on code by JRG dated 1987, 1988, and 1990.
|
|
*/
|
|
|
|
/*
|
|
* Nonsymmetric elimination tree
|
|
*/
|
|
int
|
|
sp_coletree(
|
|
int *acolst, int *acolend, /* column start and end past 1 */
|
|
int *arow, /* row indices of A */
|
|
int nr, int nc, /* dimension of A */
|
|
int *parent /* parent in elim tree */
|
|
)
|
|
{
|
|
int *root; /* root of subtee of etree */
|
|
int *firstcol; /* first nonzero col in each row*/
|
|
int rset, cset;
|
|
int row, col;
|
|
int rroot;
|
|
int p;
|
|
int *pp;
|
|
|
|
root = mxCallocInt (nc);
|
|
initialize_disjoint_sets (nc, &pp);
|
|
|
|
/* Compute firstcol[row] = first nonzero column in row */
|
|
|
|
firstcol = mxCallocInt (nr);
|
|
for (row = 0; row < nr; firstcol[row++] = nc);
|
|
for (col = 0; col < nc; col++)
|
|
for (p = acolst[col]; p < acolend[col]; p++) {
|
|
row = arow[p];
|
|
firstcol[row] = SUPERLU_MIN(firstcol[row], col);
|
|
}
|
|
|
|
/* Compute etree by Liu's algorithm for symmetric matrices,
|
|
except use (firstcol[r],c) in place of an edge (r,c) of A.
|
|
Thus each row clique in A'*A is replaced by a star
|
|
centered at its first vertex, which has the same fill. */
|
|
|
|
for (col = 0; col < nc; col++) {
|
|
cset = make_set (col, pp);
|
|
root[cset] = col;
|
|
parent[col] = nc; /* Matlab */
|
|
for (p = acolst[col]; p < acolend[col]; p++) {
|
|
row = firstcol[arow[p]];
|
|
if (row >= col) continue;
|
|
rset = find (row, pp);
|
|
rroot = root[rset];
|
|
if (rroot != col) {
|
|
parent[rroot] = col;
|
|
cset = link (cset, rset, pp);
|
|
root[cset] = col;
|
|
}
|
|
}
|
|
}
|
|
|
|
SUPERLU_FREE (root);
|
|
SUPERLU_FREE (firstcol);
|
|
finalize_disjoint_sets (pp);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* q = TreePostorder (n, p);
|
|
*
|
|
* Postorder a tree.
|
|
* Input:
|
|
* p is a vector of parent pointers for a forest whose
|
|
* vertices are the integers 0 to n-1; p[root]==n.
|
|
* Output:
|
|
* q is a vector indexed by 0..n-1 such that q[i] is the
|
|
* i-th vertex in a postorder numbering of the tree.
|
|
*
|
|
* ( 2/7/95 modified by X.Li:
|
|
* q is a vector indexed by 0:n-1 such that vertex i is the
|
|
* q[i]-th vertex in a postorder numbering of the tree.
|
|
* That is, this is the inverse of the previous q. )
|
|
*
|
|
* In the child structure, lower-numbered children are represented
|
|
* first, so that a tree which is already numbered in postorder
|
|
* will not have its order changed.
|
|
*
|
|
* Written by John Gilbert, Xerox, 10 Dec 1990.
|
|
* Based on code written by John Gilbert at CMI in 1987.
|
|
*/
|
|
|
|
static
|
|
/*
|
|
* Depth-first search from vertex v.
|
|
*/
|
|
void etdfs (
|
|
int v,
|
|
int first_kid[],
|
|
int next_kid[],
|
|
int post[],
|
|
int *postnum
|
|
)
|
|
{
|
|
int w;
|
|
|
|
for (w = first_kid[v]; w != -1; w = next_kid[w]) {
|
|
etdfs (w, first_kid, next_kid, post, postnum);
|
|
}
|
|
/* post[postnum++] = v; in Matlab */
|
|
post[v] = (*postnum)++; /* Modified by X. Li on 08/10/07 */
|
|
}
|
|
|
|
|
|
static
|
|
/*
|
|
* Depth-first search from vertex n. No recursion.
|
|
* This routine was contributed by Cédric Doucet, CEDRAT Group, Meylan, France.
|
|
*/
|
|
void nr_etdfs (int n, int *parent,
|
|
int *first_kid, int *next_kid,
|
|
int *post, int postnum)
|
|
{
|
|
int current = n, first, next;
|
|
|
|
while (postnum != n){
|
|
|
|
/* no kid for the current node */
|
|
first = first_kid[current];
|
|
|
|
/* no first kid for the current node */
|
|
if (first == -1){
|
|
|
|
/* numbering this node because it has no kid */
|
|
post[current] = postnum++;
|
|
|
|
/* looking for the next kid */
|
|
next = next_kid[current];
|
|
|
|
while (next == -1){
|
|
|
|
/* no more kids : back to the parent node */
|
|
current = parent[current];
|
|
|
|
/* numbering the parent node */
|
|
post[current] = postnum++;
|
|
|
|
/* get the next kid */
|
|
next = next_kid[current];
|
|
}
|
|
|
|
/* stopping criterion */
|
|
if (postnum==n+1) return;
|
|
|
|
/* updating current node */
|
|
current = next;
|
|
}
|
|
/* updating current node */
|
|
else {
|
|
current = first;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Post order a tree
|
|
*/
|
|
int *TreePostorder(
|
|
int n,
|
|
int *parent
|
|
)
|
|
{
|
|
int *first_kid, *next_kid; /* Linked list of children. */
|
|
int *post, postnum;
|
|
int v, dad;
|
|
|
|
/* Allocate storage for working arrays and results */
|
|
first_kid = mxCallocInt (n+1);
|
|
next_kid = mxCallocInt (n+1);
|
|
post = mxCallocInt (n+1);
|
|
|
|
/* Set up structure describing children */
|
|
for (v = 0; v <= n; first_kid[v++] = -1);
|
|
for (v = n-1; v >= 0; v--) {
|
|
dad = parent[v];
|
|
next_kid[v] = first_kid[dad];
|
|
first_kid[dad] = v;
|
|
}
|
|
|
|
/* Depth-first search from dummy root vertex #n */
|
|
postnum = 0;
|
|
#if 0
|
|
/* recursion */
|
|
etdfs (n, first_kid, next_kid, post, &postnum);
|
|
#else
|
|
/* no recursion */
|
|
nr_etdfs(n, parent, first_kid, next_kid, post, postnum);
|
|
#endif
|
|
|
|
SUPERLU_FREE (first_kid);
|
|
SUPERLU_FREE (next_kid);
|
|
return post;
|
|
}
|
|
|
|
|
|
/*
|
|
* p = spsymetree (A);
|
|
*
|
|
* Find the elimination tree for symmetric matrix A.
|
|
* This uses Liu's algorithm, and runs in time O(nz*log n).
|
|
*
|
|
* Input:
|
|
* Square sparse matrix A. No check is made for symmetry;
|
|
* elements below and on the diagonal are ignored.
|
|
* Numeric values are ignored, so any explicit zeros are
|
|
* treated as nonzero.
|
|
* Output:
|
|
* Integer array of parents representing the etree, with n
|
|
* meaning a root of the elimination forest.
|
|
* Note:
|
|
* This routine uses only the upper triangle, while sparse
|
|
* Cholesky (as in spchol.c) uses only the lower. Matlab's
|
|
* dense Cholesky uses only the upper. This routine could
|
|
* be modified to use the lower triangle either by transposing
|
|
* the matrix or by traversing it by rows with auxiliary
|
|
* pointer and link arrays.
|
|
*
|
|
* John R. Gilbert, Xerox, 10 Dec 1990
|
|
* Based on code by JRG dated 1987, 1988, and 1990.
|
|
* Modified by X.S. Li, November 1999.
|
|
*/
|
|
|
|
/*
|
|
* Symmetric elimination tree
|
|
*/
|
|
int
|
|
sp_symetree(
|
|
int *acolst, int *acolend, /* column starts and ends past 1 */
|
|
int *arow, /* row indices of A */
|
|
int n, /* dimension of A */
|
|
int *parent /* parent in elim tree */
|
|
)
|
|
{
|
|
int *root; /* root of subtree of etree */
|
|
int rset, cset;
|
|
int row, col;
|
|
int rroot;
|
|
int p;
|
|
int *pp;
|
|
|
|
root = mxCallocInt (n);
|
|
initialize_disjoint_sets (n, &pp);
|
|
|
|
for (col = 0; col < n; col++) {
|
|
cset = make_set (col, pp);
|
|
root[cset] = col;
|
|
parent[col] = n; /* Matlab */
|
|
for (p = acolst[col]; p < acolend[col]; p++) {
|
|
row = arow[p];
|
|
if (row >= col) continue;
|
|
rset = find (row, pp);
|
|
rroot = root[rset];
|
|
if (rroot != col) {
|
|
parent[rroot] = col;
|
|
cset = link (cset, rset, pp);
|
|
root[cset] = col;
|
|
}
|
|
}
|
|
}
|
|
SUPERLU_FREE (root);
|
|
finalize_disjoint_sets (pp);
|
|
return 0;
|
|
} /* SP_SYMETREE */
|