/*
-------------------------------------------------------------------
purpose --
take an adjacency structure in the (offsets[neqns+1], adjncy[*])
form and load the Graph object. note, pointers to the lists are
set, no new storage is allocated for the adjacency lists.
however, during the ordering process each adjacency lists
may be shuffled.
g -- pointer to Graph object,
must be initialized with nvtx = neqns
neqns -- # of equations
offsets -- offsets vector
adjncy -- big adjacency vector
note, the adjacency for list v is found in
adjncy[offsets[v]:offsets[v+1]-1]
also note, offsets[] and adjncy[] must be zero based,
if (offsets,adjncy) come from a harwell-boeing file, they use
the fortran numbering, so each value must be decremented to
conform with C's zero based numbering
created -- 96oct24, cca
-------------------------------------------------------------------
*/
void
Graph_setListsFromOffsets (
Graph *g,
int neqns,
int offsets[],
int adjncy[]
) {
int v, vsize ;
IVL *adjIVL ;
/*
---------------
check the input
---------------
*/
if ( g == NULL
|| neqns <= 0
|| offsets == NULL
|| adjncy == NULL ) {
fprintf(stderr,
"\n fatal error in Graph_setListsFromOffsets(%p,%d,%p,%p)"
"\n bad input\n", g, neqns, offsets, adjncy) ;
exit(-1) ;
}
/*
---------------------------
initialize the Graph object
---------------------------
*/
Graph_init1(g, 0, neqns, 0, 0, IVL_CHUNKED, IVL_CHUNKED) ;
adjIVL = g->adjIVL ;
/*
-----------------------------
set the pointers to the lists
-----------------------------
*/
for ( v = 0 ; v < neqns ; v++ ) {
if ( (vsize = offsets[v+1] - offsets[v]) > 0 ) {
IVL_setPointerToList(adjIVL, v, vsize, &adjncy[offsets[v]]) ;
}
}
return ; }
/*
-------------------------------------------------------
purpose -- to read in a Graph object from a CHACO file
input --
fn -- filename
return value -- 1 if success, 0 if failure
created -- 98sep20, jjs
--------------------------------------------------------
*/
int
Graph_readFromChacoFile (
Graph *graph,
char *fn
) {
char *rc ;
FILE *fp;
int nvtx, nedges, format;
char string[BUFLEN], *s1, *s2;
int k, v, vsize, w, vwghts, ewghts;
int *adjncy, *weights, *vwghtsINT;
IVL *adjIVL, *ewghtIVL;
/*
---------------
check the input
---------------
*/
if ((graph == NULL) || (fn == NULL)) {
fprintf(stderr, "\n error in Graph_readFromFile(%p,%s)"
"\n bad input\n", graph, fn);
return(0);
}
/*
---------------------
clear the data fields
---------------------
*/
Graph_clearData(graph);
/*
----------------------------------------------
open file and read in nvtx, nedges, and format
----------------------------------------------
*/
if ((fp = fopen(fn, "r")) == (FILE*)NULL) {
fprintf(stderr, "\n error in Graph_readFromChacoFile(%p,%s)"
"\n unable to open file %s", graph, fn, fn);
return(0);
}
/*
-------------
skip comments
-------------
*/
do {
rc = fgets(string, BUFLEN, fp) ;
if ( rc == NULL ) {
fprintf(stderr, "\n error in Graph_readFromChacoFile()"
"\n error skipping comments in file %s\n", fn) ;
return(0) ;
}
} while ( string[0] == '%');
/*
-------------------------------------------------
read in # vertices, # edges and (optional) format
-------------------------------------------------
*/
format = 0;
if (sscanf(string, "%d %d %d", &nvtx, &nedges, &format) < 2) {
fprintf(stderr, "\n error in Graph_readFromChacoFile(%p,%s)"
"\n unable to read header of file %s", graph, fn, fn);
return(0);
}
ewghts = ((format % 10) > 0);
vwghts = (((format / 10) % 10) > 0);
if (format >= 100) {
fprintf(stderr, "\n error in Graph_readFromChacoFile(%p,%s)"
"\n unknown format", graph, fn);
return(0);
}
/*
------------------------------------------------------------------
initialize vector(s) to hold adjacency and (optional) edge weights
------------------------------------------------------------------
*/
adjncy = IVinit(nvtx, -1) ;
if ( ewghts ) {
weights = IVinit(nvtx, -1) ;
} else {
weights = NULL ;
}
/*
---------------------------
initialize the Graph object
---------------------------
*/
nedges *= 2;
nedges += nvtx;
Graph_init1(graph, 2*ewghts+vwghts, nvtx, 0, nedges,
IVL_CHUNKED, IVL_CHUNKED);
adjIVL = graph->adjIVL;
if (ewghts) {
ewghtIVL = graph->ewghtIVL;
weights[0] = 0; /* self loops have no weight */
}
if (vwghts) vwghtsINT = graph->vwghts;
/*
---------------------------
read in all adjacency lists
---------------------------
*/
k = 0;
for (v = 0; v < nvtx; v++) {
/*
-------------
skip comments
-------------
*/
do {
rc = fgets(string, BUFLEN, fp);
if ( rc == NULL ) {
fprintf(stderr, "\n error in Graph_readFromChacoFile()"
"\n error reading adjacency for vertex %d in file %s\n",
v, fn) ;
IVfree(adjncy) ;
if ( weights != NULL ) {
IVfree(weights) ;
}
return(0) ;
}
} while ( string[0] == '%');
/*
-------------------------
check for buffer overflow
-------------------------
*/
if (strlen(string) == BUFLEN-1) {
fprintf(stderr, "\n error in Graph_readFromChacoFile(%p,%s)"
"\n unable to read adjacency lists of file %s (line "
"buffer too small)\n", graph, fn, fn);
IVfree(adjncy) ;
if ( weights != NULL ) {
IVfree(weights) ;
}
return(0);
}
/*
----------------------------------------------
read in (optional) vertex weight,
adjacent vertices, and (optional) edge weights
----------------------------------------------
*/
s1 = string;
if (vwghts) vwghtsINT[v] = (int)strtol(string, &s1, 10);
adjncy[0] = v; /* insert self loop needed by spooles */
if ( ewghts ) {
weights[0] = 0;
}
vsize = 1;
while ((w = (int)strtol(s1, &s2, 10)) > 0) {
adjncy[vsize] = --w; /* node numbering starts with 0 */
s1 = s2;
if (ewghts)
{ weights[vsize] = (int)strtol(s1, &s2, 10);
s1 = s2;
}
vsize++;
}
/*
---------------------------------
sort the lists in ascending order
---------------------------------
*/
if ( ewghts ) {
IV2qsortUp(vsize, adjncy, weights) ;
} else {
IVqsortUp(vsize, adjncy) ;
}
/*
--------------------------------
set the lists in the IVL objects
--------------------------------
*/
IVL_setList(adjIVL, v, vsize, adjncy);
if (ewghts) IVL_setList(ewghtIVL, v, vsize, weights);
k += vsize;
}
/*
-----------------------------------
close the file and do a final check
-----------------------------------
*/
fclose(fp);
/*
------------------------
free the working storage
------------------------
*/
IVfree(adjncy) ;
if ( weights != NULL ) {
IVfree(weights) ;
}
/*
----------------
check for errors
----------------
*/
if ((k != nedges) || (v != nvtx)) {
fprintf(stderr, "\n error in Graph_readFromChacoFile()"
"\n number of nodes/edges does not match with header of %s"
"\n k %d, nedges %d, v %d, nvtx %d\n",
fn, k, nedges, v, nvtx);
return(0);
}
return(1); }
/*
----------------------------------------------------------------
purpose --
if the elimination has halted before all the stages have been
eliminated, then create the schur complement graph and the map
from the original vertices those in the schur complement graph.
schurGraph -- Graph object to contain the schur complement graph
VtoPhi -- IV object to contain the map from vertices in V
to schur complement vertices in Phi
created -- 97feb01, cca
----------------------------------------------------------------
*/
void
MSMD_makeSchurComplement (
MSMD *msmd,
Graph *schurGraph,
IV *VtoPhiIV
) {
int nedge, nPhi, nvtx, totewght, totvwght ;
int *mark, *rep, *VtoPhi, *vwghts ;
int count, *list ;
int ierr, ii, size, *adj ;
int phi, psi, tag ;
IP *ip ;
IVL *adjIVL ;
MSMDvtx *u, *v, *vertices, *vfirst, *vlast, *w ;
/*
---------------
check the input
---------------
*/
if ( msmd == NULL || schurGraph == NULL || VtoPhiIV == NULL ) {
fprintf(stderr,
"\n\n fatal error in MSMD_makeSchurComplement(%p,%p,%p)"
"\n bad input\n", msmd, schurGraph, VtoPhiIV) ;
exit(-1) ;
}
vertices = msmd->vertices ;
nvtx = msmd->nvtx ;
/*
-------------------------------------
initialize the V-to-Phi map IV object
-------------------------------------
*/
IV_clearData(VtoPhiIV) ;
IV_setSize(VtoPhiIV, nvtx) ;
IV_fill(VtoPhiIV, -2) ;
VtoPhi = IV_entries(VtoPhiIV) ;
/*
---------------------------------------------
count the number of Schur complement vertices
---------------------------------------------
*/
vfirst = vertices ;
vlast = vfirst + nvtx - 1 ;
nPhi = 0 ;
for ( v = vfirst ; v <= vlast ; v++ ) {
#if MYDEBUG > 0
fprintf(stdout, "\n v->id = %d, v->status = %c", v->id, v->status) ;
fflush(stdout) ;
#endif
switch ( v->status ) {
case 'L' :
case 'E' :
case 'I' :
break ;
case 'B' :
VtoPhi[v->id] = nPhi++ ;
#if MYDEBUG > 0
fprintf(stdout, ", VtoPhi[%d] = %d", v->id, VtoPhi[v->id]) ;
fflush(stdout) ;
#endif
break ;
default :
break ;
}
}
#if MYDEBUG > 0
fprintf(stdout, "\n\n nPhi = %d", nPhi) ;
fflush(stdout) ;
#endif
/*
----------------------------------------------------
get the representative vertex id for each Phi vertex
----------------------------------------------------
*/
rep = IVinit(nPhi, -1) ;
for ( v = vfirst ; v <= vlast ; v++ ) {
if ( (phi = VtoPhi[v->id]) >= 0 ) {
#if MYDEBUG > 0
fprintf(stdout, "\n rep[%d] = %d", phi, v->id) ;
fflush(stdout) ;
#endif
rep[phi] = v->id ;
}
}
/*
------------------------------------------
set the map for indistinguishable vertices
------------------------------------------
*/
for ( v = vfirst ; v <= vlast ; v++ ) {
if ( v->status == 'I' ) {
w = v ;
while ( w->status == 'I' ) {
w = w->par ;
}
#if MYDEBUG > 0
fprintf(stdout, "\n v = %d, status = %c, w = %d, status = %c",
v->id, v->status, w->id, w->status) ;
fflush(stdout) ;
#endif
VtoPhi[v->id] = VtoPhi[w->id] ;
}
}
#if MYDEBUG > 0
fprintf(stdout, "\n\n VtoPhi") ;
IV_writeForHumanEye(VtoPhiIV, stdout) ;
fflush(stdout) ;
#endif
/*
---------------------------
initialize the Graph object
---------------------------
*/
Graph_clearData(schurGraph) ;
Graph_init1(schurGraph, 1, nPhi, 0, 0, IVL_CHUNKED, IVL_CHUNKED) ;
adjIVL = schurGraph->adjIVL ;
vwghts = schurGraph->vwghts ;
#if MYDEBUG > 0
fprintf(stdout, "\n\n schurGraph initialized, nvtx = %d",
schurGraph->nvtx) ;
fflush(stdout) ;
#endif
/*
-------------------------------
fill the vertex adjacency lists
-------------------------------
*/
mark = IVinit(nPhi, -1) ;
list = IVinit(nPhi, -1) ;
nedge = totvwght = totewght = 0 ;
for ( phi = 0 ; phi < nPhi ; phi++ ) {
/*
-----------------------------
get the representative vertex
-----------------------------
*/
v = vfirst + rep[phi] ;
#if MYDEBUG > 0
fprintf(stdout, "\n phi = %d, v = %d", phi, v->id) ;
fflush(stdout) ;
MSMDvtx_print(v, stdout) ;
fflush(stdout) ;
#endif
count = 0 ;
tag = v->id ;
/*
---------------------------
load self in adjacency list
---------------------------
*/
mark[phi] = tag ;
totewght += v->wght * v->wght ;
#if MYDEBUG > 0
fprintf(stdout, "\n mark[%d] = %d", phi, mark[phi]) ;
fflush(stdout) ;
#endif
list[count++] = phi ;
/*
----------------------------------------
load boundary lists of adjacent subtrees
----------------------------------------
*/
for ( ip = v->subtrees ; ip != NULL ; ip = ip->next ) {
u = vertices + ip->val ;
size = u->nadj ;
adj = u->adj ;
#if MYDEBUG > 0
fprintf(stdout, "\n subtree %d :", u->id) ;
IVfp80(stdout, size, adj, 15, &ierr) ;
fflush(stdout) ;
#endif
for ( ii = 0 ; ii < size ; ii++ ) {
w = vertices + adj[ii] ;
#if MYDEBUG > 0
fprintf(stdout, "\n w %d, status %c, psi %d",
w->id, w->status, VtoPhi[w->id]) ;
fflush(stdout) ;
#endif
if ( (psi = VtoPhi[w->id]) != -2 && mark[psi] != tag ) {
mark[psi] = tag ;
#if MYDEBUG > 0
fprintf(stdout, ", mark[%d] = %d", psi, mark[psi]) ;
fflush(stdout) ;
#endif
list[count++] = psi ;
totewght += v->wght * w->wght ;
}
}
}
/*
----------------------
load adjacent vertices
----------------------
*/
size = v->nadj ;
adj = v->adj ;
for ( ii = 0 ; ii < size ; ii++ ) {
w = vertices + adj[ii] ;
if ( (psi = VtoPhi[w->id]) != -2 && mark[psi] != tag ) {
mark[psi] = tag ;
list[count++] = psi ;
totewght += v->wght * w->wght ;
}
}
/*
---------------------------------------------
sort the list and inform adjacency IVL object
---------------------------------------------
*/
IVqsortUp(count, list) ;
IVL_setList(adjIVL, phi, count, list) ;
/*
--------------------------------------
set the vertex weight and increment
the total vertex weight and edge count
--------------------------------------
*/
vwghts[phi] = v->wght ;
totvwght += v->wght ;
nedge += count ;
}
schurGraph->totvwght = totvwght ;
schurGraph->nedges = nedge ;
schurGraph->totewght = totewght ;
/*
------------------------
free the working storage
------------------------
*/
IVfree(list) ;
IVfree(mark) ;
IVfree(rep) ;
return ; }
/*
---------------------------------------------------------------------
purpose -- take a Graph object and a map to expand it, create and
return a bigger unit weight Graph object. this is useful
for expanding a compressed graph into a unit weight graph.
created -- 96mar02, cca
---------------------------------------------------------------------
*/
Graph *
Graph_expand (
Graph *g,
int nvtxbig,
int map[]
) {
Graph *gbig ;
int count, ii, nedge, nvtx, v, vbig, vsize, w ;
int *head, *indices, *link, *mark, *vadj ;
IVL *adjIVL, *adjbigIVL ;
/*
---------------
check the input
---------------
*/
if ( g == NULL || nvtxbig <= 0 || map == NULL ) {
fprintf(stderr, "\n fatal error in Graph_expand(%p,%d,%p)"
"\n bad input\n", g, nvtxbig, map) ;
spoolesFatal();
}
nvtx = g->nvtx ;
adjIVL = g->adjIVL ;
/*
----------------------------------------
set up the linked lists for the vertices
----------------------------------------
*/
head = IVinit(nvtx, -1) ;
link = IVinit(nvtxbig, -1) ;
for ( vbig = 0 ; vbig < nvtxbig ; vbig++ ) {
v = map[vbig] ;
link[vbig] = head[v] ;
head[v] = vbig ;
}
/*
--------------------------------
create the expanded Graph object
--------------------------------
*/
gbig = Graph_new() ;
Graph_init1(gbig, 0, nvtxbig, 0, 0, IVL_CHUNKED, IVL_CHUNKED) ;
adjbigIVL = gbig->adjIVL ;
/*
-------------------------------------------
fill the lists in the expanded Graph object
-------------------------------------------
*/
indices = IVinit(nvtxbig, -1) ;
mark = IVinit(nvtx, -1) ;
nedge = 0 ;
for ( v = 0 ; v < nvtx ; v++ ) {
if ( head[v] != -1 ) {
/*
------------------------------
load the indices that map to v
------------------------------
*/
mark[v] = v ;
count = 0 ;
for ( vbig = head[v] ; vbig != -1 ; vbig = link[vbig] ) {
indices[count++] = vbig ;
}
/*
---------------------------------------------------
load the indices that map to vertices adjacent to v
---------------------------------------------------
*/
IVL_listAndSize(adjIVL, v, &vsize, &vadj) ;
for ( ii = 0 ; ii < vsize ; ii++ ) {
w = vadj[ii] ;
if ( w < nvtx && mark[w] != v ) {
mark[w] = v ;
for ( vbig = head[w] ; vbig != -1 ; vbig = link[vbig] ) {
indices[count++] = vbig ;
}
}
}
/*
--------------------------------------
sort the index list in ascending order
--------------------------------------
*/
IVqsortUp(count, indices) ;
/*
-------------------------------------------------------
each vertex in the big IVL object has its own list.
-------------------------------------------------------
*/
for ( vbig = head[v] ; vbig != -1 ; vbig = link[vbig] ) {
IVL_setList(adjbigIVL, vbig, count, indices) ;
nedge += count ;
}
}
}
gbig->nedges = nedge ;
/*
------------------------
free the working storage
------------------------
*/
IVfree(head) ;
IVfree(link) ;
IVfree(indices) ;
IVfree(mark) ;
return(gbig) ; }
/*
-------------------------------------------------------------------
purpose -- take an adjacency structure in the
(offsets[neqns+1], adjncy[*]) form
and load the Graph object
g -- pointer to Graph object, must be initialized with nvtx = neqns
neqns -- # of equations
offsets -- offsets vector
adjncy -- big adjacency vector
note, the adjacency for list v is found in
adjncy[offsets[v]:offsets[v+1]-1]
also note, offsets[] and adjncy[] must be zero based,
if (offsets,adjncy) come from a harwell-boeing file, they use
the fortran numbering, so each value must be decremented to
conform with C's zero based numbering
flag -- task flag
flag = 0 --> just set the adjacency list for v to be that
found in adjncy[offsets[v]:offsets[v+1]-1]
flag = 1 --> the input adjancency is just the upper triangle
(or strict upper triangle) as from a harwell-boeing
file. fill the Graph object with the full adjacency
structure, including (v,v) edges
created -- 96mar16, cca
-------------------------------------------------------------------
*/
void
Graph_fillFromOffsets (
Graph *g,
int neqns,
int offsets[],
int adjncy[],
int flag
) {
IVL *adjIVL ;
/*
---------------
check the input
---------------
*/
if ( g == NULL
|| neqns <= 0
|| offsets == NULL
|| adjncy == NULL
|| flag < 0
|| flag > 1 ) {
fprintf(stderr,
"\n fatal error in Graph_fillFromOffsets(%p,%d,%p,%p,%d)"
"\n bad input\n", g, neqns, offsets, adjncy, flag) ;
exit(-1) ;
}
/*
---------------------------
initialize the Graph object
---------------------------
*/
Graph_init1(g, 0, neqns, 0, 0, IVL_CHUNKED, IVL_CHUNKED) ;
adjIVL = g->adjIVL ;
if ( flag == 0 ) {
int count, ii, nedge, v, w ;
int *list, *mark ;
/*
----------------------------------------------
simple map, do not enforce symmetric structure
----------------------------------------------
*/
list = IVinit(neqns, -1) ;
mark = IVinit(neqns, -1) ;
for ( v = 0, nedge = 0 ; v < neqns ; v++ ) {
count = 0 ;
for ( ii = offsets[v] ; ii < offsets[v+1] ; ii++ ) {
w = adjncy[ii] ;
if ( v == neqns ) {
fprintf(stdout, "\n hey there!! (v,w) = (%d,%d)", v, w) ;
}
if ( 0 <= w && w < neqns && mark[w] != v ) {
list[count++] = w ;
mark[w] = v ;
}
}
if ( mark[v] != v ) {
list[count++] = v ;
mark[v] = v ;
}
IVqsortUp(count, list) ;
IVL_setList(adjIVL, v, count, list) ;
nedge += count ;
}
g->totvwght = neqns ;
g->totewght = g->nedges = nedge ;
/*
----------------------------
now free the working storage
----------------------------
*/
IVfree(list) ;
IVfree(mark) ;
} else {
int ii, jj, u, v, vsize, w ;
int *head, *link, *list, *sizes, *vadj ;
int **p_adj ;
/*
-------------------------------------------
enforce symmetric structure and (v,v) edges
make a first pass to check the input
-------------------------------------------
*/
fprintf(stdout, "\n offsets") ;
IVfprintf(stdout, neqns+1, offsets) ;
for ( v = 0 ; v < neqns ; v++ ) {
fprintf(stdout, "\n v = %d", v) ;
for ( ii = offsets[v] ; ii < offsets[v+1] ; ii++ ) {
fprintf(stdout, "\n w = %d", adjncy[ii]) ;
if ( (w = adjncy[ii]) < v || neqns <= w ) {
fprintf(stderr,
"\n fatal error in Graph_fillFromOffsets(%p,%d,%p,%p,%d)"
"\n list %d, entry %d\n", g, neqns, offsets, adjncy,
flag, v, w) ;
exit(-1) ;
}
}
}
head = IVinit(neqns, -1) ;
link = IVinit(neqns, -1) ;
list = IVinit(neqns, -1) ;
sizes = IVinit(neqns, 0) ;
p_adj = PIVinit(neqns) ;
for ( v = 0 ; v < neqns ; v++ ) {
vsize = 0 ;
/*
-------------------------
add edges to vertices < v
-------------------------
*/
while ( (u = head[v]) != -1 ) {
head[v] = link[u] ;
list[vsize++] = u ;
if ( --sizes[u] > 0 ) {
w = *(++p_adj[u]) ;
link[u] = head[w] ;
head[w] = u ;
}
}
/*
-----------------
add in edge (v,v)
-----------------
*/
list[vsize++] = v ;
jj = vsize ;
/*
-------------------------
add edges to vertices > v
-------------------------
*/
for ( ii = offsets[v] ; ii < offsets[v+1] ; ii++ ) {
if ( (w = adjncy[ii]) != v ) {
list[vsize++] = w ;
}
}
/*
---------------------
sort and set the list
---------------------
*/
IVqsortUp(vsize, list) ;
IVL_setList(adjIVL, v, vsize, list) ;
/*
--------------------------------------------------
link v to first vertex in its lists greater than v
--------------------------------------------------
*/
if ( jj < vsize ) {
IVL_listAndSize(adjIVL, v, &vsize, &vadj) ;
w = vadj[jj] ;
link[v] = head[w] ;
head[w] = v ;
sizes[v] = vsize - jj ;
p_adj[v] = &vadj[jj] ;
}
g->nedges += vsize ;
}
g->totvwght = neqns ;
g->totewght = g->nedges ;
/*
----------------------------
now free the working storage
----------------------------
*/
IVfree(head) ;
IVfree(link) ;
IVfree(list) ;
IVfree(sizes) ;
PIVfree(p_adj) ;
}
return ; }
/*
-----------------------------------------------------------
purpose -- return the Y by Y graph where (y1,y2) is an edge
if there exists a x in X such that (x,y1) and
(x,y2) are edges in the bipartite graph.
created -- 95dec07, cca
-----------------------------------------------------------
*/
Graph *
BPG_makeGraphYbyY (
BPG *bpg
) {
Graph *graph, *gYbyY ;
int count, ii, jj, nX, nY, x, xsize, y, ysize, z ;
int *list, *mark, *xadj, *yadj ;
/*
---------------
check the input
---------------
*/
if ( bpg == NULL ) {
fprintf(stdout, "\n fatal error in BPG_makeGraphXbyX(%p)"
"\n bad input\n", bpg) ;
spoolesFatal();
}
/*
----------------------
check for quick return
----------------------
*/
if ( (graph = bpg->graph) == NULL || (nY = bpg->nY) <= 0 ) {
return(NULL) ;
}
nX = bpg->nX ;
/*
--------------------
initialize the graph
--------------------
*/
gYbyY = Graph_new() ;
Graph_init1(gYbyY, graph->type, nY, 0, 0, IVL_CHUNKED, IVL_CHUNKED) ;
/*
--------------
fill the graph
--------------
*/
mark = IVinit(nY, -1) ;
list = IVinit(nY, -1) ;
for ( y = 0 ; y < nY ; y++ ) {
Graph_adjAndSize(graph, nX + y, &ysize, &yadj) ;
mark[y] = y ;
for ( ii = 0, count = 0 ; ii < ysize ; ii++ ) {
x = yadj[ii] ;
Graph_adjAndSize(graph, x, &xsize, &xadj) ;
for ( jj = 0 ; jj < xsize ; jj++ ) {
z = xadj[jj] ;
if ( mark[z] != y ) {
mark[z] = y ;
list[count++] = z ;
}
}
}
if ( count > 0 ) {
IVqsortUp(count, list) ;
IVL_setList(gYbyY->adjIVL, nX + y, count, list) ;
}
}
IVfree(list) ;
IVfree(mark) ;
/*
---------------------------------------
set vertex weight vector if appropriate
---------------------------------------
*/
if ( graph->type % 2 == 1 ) {
IVcopy(nY, gYbyY->vwghts, graph->vwghts + nX) ;
}
return(gYbyY) ; }
/*
----------------------------------------------------
create a Graph object that holds the adjacency graph
of the assembled elements.
created -- 95nov03, cca
----------------------------------------------------
*/
Graph *
EGraph_mkAdjGraph (
EGraph *egraph
) {
int elem, esize, i, nelem, nvtx, v, vsize, w ;
int *eind, *head, *link, *marker, *offsets, *vind ;
IVL *eadjIVL, *gadjIVL ;
Graph *graph ;
/*
---------------
check the input
---------------
*/
if ( egraph == NULL || (eadjIVL = egraph->adjIVL) == NULL ) {
fprintf(stderr, "\n fatal error in EGraph_mkAdjGraph(%p)"
"\n bad input\n", egraph) ;
spoolesFatal();
}
nelem = egraph->nelem ;
nvtx = egraph->nvtx ;
/*
--------------------------------
set up the linked list structure
--------------------------------
*/
head = IVinit(nvtx, -1) ;
link = IVinit(nelem, -1) ;
offsets = IVinit(nelem, 0) ;
/*
-----------------------------------------------------------
sort the vertices in each element list into ascending order
and link them into their first vertex
-----------------------------------------------------------
*/
for ( elem = 0 ; elem < nelem ; elem++ ) {
IVL_listAndSize(eadjIVL, elem, &esize, &eind) ;
if ( esize > 0 ) {
IVqsortUp(esize, eind) ;
v = eind[0] ;
link[elem] = head[v] ;
head[v] = elem ;
}
}
/*
---------------------------
create the new Graph object
---------------------------
*/
graph = Graph_new() ;
Graph_init1(graph, egraph->type, nvtx, 0, 0, IVL_CHUNKED, IVL_CHUNKED) ;
gadjIVL = graph->adjIVL ;
/*
----------------------
loop over the vertices
----------------------
*/
vind = IVinit(nvtx, -1) ;
marker = IVinit(nvtx, -1) ;
for ( v = 0 ; v < nvtx ; v++ ) {
/*
---------------------------------
loop over the supporting elements
---------------------------------
*/
vsize = 0 ;
vind[vsize++] = v ;
marker[v] = v ;
while ( (elem = head[v]) != -1 ) {
/*
fprintf(stdout, "\n checking out element %d :", jelem) ;
*/
head[v] = link[elem] ;
IVL_listAndSize(eadjIVL, elem, &esize, &eind) ;
for ( i = 0 ; i < esize ; i++ ) {
w = eind[i] ;
if ( marker[w] != v ) {
marker[w] = v ;
vind[vsize++] = w ;
}
}
if ( (i = ++offsets[elem]) < esize ) {
w = eind[i] ;
link[elem] = head[w] ;
head[w] = elem ;
}
}
IVqsortUp(vsize, vind) ;
IVL_setList(gadjIVL, v, vsize, vind) ;
}
graph->nedges = gadjIVL->tsize ;
if ( egraph->type == 0 ) {
graph->totvwght = nvtx ;
} else if ( egraph->type == 1 ) {
/*
------------------------------
fill the vertex weights vector
------------------------------
*/
IVcopy(nvtx, graph->vwghts, egraph->vwghts) ;
graph->totvwght = IVsum(nvtx, graph->vwghts) ;
}
graph->totewght = graph->nedges ;
/*
------------------------
free the working storage
------------------------
*/
IVfree(head) ;
IVfree(link) ;
IVfree(marker) ;
IVfree(vind) ;
IVfree(offsets) ;
return(graph) ; }