void 
makecgraph (
    struct vtx_data **graph,	/* array of vtx data for graph */
    int nvtxs,		/* number of vertices in graph */
    struct vtx_data ***pcgraph,	/* coarsened version of graph */
    int *pcnvtxs,		/* number of vtxs in coarsened graph */
    int *pcnedges,		/* number of edges in coarsened graph */
    int *mflag,		/* flag indicating vtx matched or not */
    int *v2cv,			/* mapping from vtxs to coarsened vtxs */
    int nmerged,		/* number of merged vertices */
    int using_ewgts,		/* are edge weights being used? */
    int igeom,		/* dimensions of geometric data */
    float **coords,		/* coordinates for vertices */
    float **ccoords		/* coordinates for coarsened vertices */
)
{
    extern double make_cgraph_time;
    extern int DEBUG_COARSEN;	/* debug flag for coarsening output */
    extern int COARSEN_VWGTS;	/* turn off vertex weights in coarse graph? */
    extern int COARSEN_EWGTS;	/* turn off edge weights in coarse graph? */
    struct vtx_data **cgraph=NULL;	/* coarsened version of graph */
    struct vtx_data *links=NULL;	/* space for all the vertex data */
    struct vtx_data **gptr=NULL;	/* loops through cgraph */
    struct vtx_data *cgptr=NULL;	/* loops through cgraph */
    int      *start=NULL;		/* start of edgevals list for each vertex */
    int      *iptr=NULL;		/* loops through integer arrays */
    int      *seenflag=NULL;		/* flags for vtxs already put in edge list */
    int      *sptr=NULL;		/* loops through seenflags */
    float    *eweights=NULL;		/* space for edge weights in coarsened graph */
    float    *fptr=NULL;		/* loops through eweights */
    float     ewgt=0.0;		/* edge weight */
    double    ewgt_sum;		/* sum of edge weights */
    double    time;		/* timing parameters */
    int       nseen;		/* number of edges of coarse graph seen so far */
    int       cnvtxs;		/* number of vtxs in coarsened graph */
    int       cnedges;		/* twice number of edges in coarsened graph */
    int       neighbor;		/* neighboring vertex */
    int       size;		/* space needed for coarsened graph */
    int      *edges=NULL;		/* space for edges in coarsened graph */
    int       cvtx;		/* vertex number in coarsened graph */
    int       cneighbor;	/* neighboring vertex number in coarsened graph */
    int       i, j;		/* loop counters */
    double    seconds();

    void      makev2cv(), countcedges();

    /* Compute the number of vertices and edges in the coarsened graph, */
    /* and construct start pointers into coarsened edge array. */
    time = seconds();

    *pcnvtxs = cnvtxs = nvtxs - nmerged;

    /* Construct mapping from original graph vtxs to coarsened graph vtxs. */
    makev2cv(mflag, nvtxs, v2cv);

    start = smalloc((cnvtxs + 2) * sizeof(int));

    seenflag = smalloc((cnvtxs + 1) * sizeof(int));
    sptr = seenflag;
    for (i = cnvtxs; i; i--)
	*(++sptr) = 0;

    countcedges(graph, nvtxs, start, seenflag, mflag, v2cv, pcnedges);
    cnedges = *pcnedges;

    if (DEBUG_COARSEN > 0) {
	printf(" Coarse graph has %d vertices and %d edges\n", cnvtxs, cnedges);
    }

    /* Now allocate space for the new graph. */
    *pcgraph = cgraph = smalloc((cnvtxs + 1) * sizeof(struct vtx_data *));
    links = smalloc(cnvtxs * sizeof(struct vtx_data));

    size = 2 * cnedges + cnvtxs;
    edges = smalloc(size * sizeof(int));
    if (COARSEN_EWGTS) {
	eweights = smalloc(size * sizeof(float));
    }

    /* Fill in simple data fields for coarsened graph. */
    /* Edges and weights are put in later. */
    gptr = cgraph;
    sptr = seenflag;
    for (i = 1; i <= cnvtxs; i++) {
	size = start[i + 1] - start[i] + 1;
	links->nedges = size;
	links->edges = edges;
	links->edges[0] = i;
	edges += size;
	if (COARSEN_VWGTS)
	    links->vwgt = 0;
	else
	    links->vwgt = 1;
	if (COARSEN_EWGTS) {
	    links->ewgts = eweights;
	    eweights += size;
	}
	else
	    links->ewgts = NULL;
	*(++gptr) = links++;
	*(++sptr) = 0;
    }
    sfree(start);

    /* Now form new vertex weights by adding those from contracted edges. */
    if (COARSEN_VWGTS) {
	gptr = graph;
	for (i = 1; i <= nvtxs; i++) {
	    cgraph[v2cv[i]]->vwgt += (*(++gptr))->vwgt;
	}
    }

    /* Use the renumbering to fill in the edge lists for the new graph. */
    ewgt = 1;
    for (i = 1; i <= nvtxs; i++) {
	if (mflag[i] > i || mflag[i] == 0) {
	    /* Unmatched edge, or first appearance of matched edge. */
	    nseen = 1;
	    cvtx = v2cv[i];
	    cgptr = cgraph[cvtx];
	    ewgt_sum = 0;

	    iptr = graph[i]->edges;
	    if (using_ewgts)
		fptr = graph[i]->ewgts;
	    for (j = graph[i]->nedges - 1; j; j--) {
		neighbor = *(++iptr);
		cneighbor = v2cv[neighbor];
		if (cneighbor != cvtx) {
		    if (using_ewgts)
			ewgt = *(++fptr);
		    ewgt_sum += ewgt;

		    /* Seenflags being used as map from cvtx to index. */
		    if (seenflag[cneighbor] == 0) {	/* New neighbor. */
			cgptr->edges[nseen] = cneighbor;
			if (COARSEN_EWGTS)
			    cgptr->ewgts[nseen] = ewgt;
			seenflag[cneighbor] = nseen++;
		    }
		    else {	/* Already seen neighbor. */
			if (COARSEN_EWGTS)
			    cgptr->ewgts[seenflag[cneighbor]] += ewgt;
		    }
		}
		else if (using_ewgts)
		    ++fptr;
	    }

	    if (mflag[i] > i) {	/* Now handle the matched vertex. */
		iptr = graph[mflag[i]]->edges;
		if (using_ewgts)
		    fptr = graph[mflag[i]]->ewgts;
		for (j = graph[mflag[i]]->nedges - 1; j; j--) {
		    neighbor = *(++iptr);
		    cneighbor = v2cv[neighbor];
		    if (cneighbor != cvtx) {
			if (using_ewgts)
			    ewgt = *(++fptr);
			ewgt_sum += ewgt;

			if (seenflag[cneighbor] == 0) {	/* New neighbor. */
			    cgptr->edges[nseen] = cneighbor;
			    if (COARSEN_EWGTS)
				cgptr->ewgts[nseen] = ewgt;
			    seenflag[cneighbor] = nseen++;
			}
			else {	/* Already seen neighbor. */
			    if (COARSEN_EWGTS)
				cgptr->ewgts[seenflag[cneighbor]] += ewgt;
			}
		    }
		    else if (using_ewgts)
			++fptr;
		}
	    }
	    if (COARSEN_EWGTS)
		cgptr->ewgts[0] = -ewgt_sum;
	    /* Now clear the seenflag values. */
	    iptr = cgraph[cvtx]->edges;
	    for (j = cgraph[cvtx]->nedges - 1; j; j--) {
		seenflag[*(++iptr)] = 0;
	    }
	}
    }

    sfree(seenflag);

    /* If desired, make new vtx coordinates = center-of-mass of their parents. */
    if (coords != NULL && ccoords != NULL && igeom > 0) {
	makeccoords(graph, nvtxs, cnvtxs, mflag, v2cv, igeom, coords, ccoords);
    }

    make_cgraph_time += seconds() - time;
}
Beispiel #2
0
void 
makefgraph (
    struct vtx_data **graph,	/* array of vtx data for graph */
    int nvtxs,		/* number of vertices in graph */
    int nedges,		/* number of edges in graph */
    struct vtx_data ***pcgraph,	/* coarsened version of graph */
    int cnvtxs,		/* number of vtxs in coarsened graph */
    int *pcnedges,		/* number of edges in coarsened graph */
    int *v2cv,			/* mapping from vtxs to coarsened vtxs */
    int using_ewgts,		/* are edge weights being used? */
    int igeom,		/* dimensions of geometric data */
    float **coords,		/* coordinates for vertices */
    float **ccoords		/* coordinates for coarsened vertices */
)
{
    extern double make_cgraph_time;
    extern int DEBUG_COARSEN;	/* debug flag for coarsening output */
    extern int COARSEN_VWGTS;	/* turn off vertex weights in coarse graph? */
    extern int COARSEN_EWGTS;	/* turn off edge weights in coarse graph? */
    struct vtx_data **cgraph=NULL;/* coarsened version of graph */
    struct vtx_data *links=NULL;/* space for all the vertex data */
    struct vtx_data **gptr=NULL;/* loops through cgraph */
    struct vtx_data *cgptr=NULL;/* loops through cgraph */
    int      *iptr=NULL;	/* loops through integer arrays */
    int      *seenflag=NULL;	/* flags for vtxs already put in edge list */
    int      *sptr=NULL;	/* loops through seenflags */
    int      *cv2v_vals=NULL;	/* vtxs corresponding to each cvtx */
    int      *cv2v_ptrs=NULL;	/* indices into cv2v_vals */
    float    *eweights=NULL;	/* space for edge weights in coarsened graph */
    float    *ewptr=NULL;	/* loops through eweights */
    float    *fptr=NULL;	/* loops through eweights */
    float     ewgt;		/* edge weight */
    double    ewgt_sum;		/* sum of edge weights */
    double    time;		/* timing parameters */
    int       nseen;		/* number of edges of coarse graph seen so far */
    int       vtx;		/* vertex in original graph */
    int       cvtx;		/* vertex in coarse graph */
    int       cnedges;		/* twice number of edges in coarsened graph */
    int       neighbor;		/* neighboring vertex */
    int       size;		/* space needed for coarsened graph */
    int      *edges=NULL;	/* space for edges in coarsened graph */
    int      *eptr=NULL;	/* loops through edges data structure */
    int       cneighbor;	/* neighboring vertex number in coarsened graph */
    int       i, j;		/* loop counters */
    double    seconds();
    void      makeccoords();

    /* Compute the number of vertices and edges in the coarsened graph, */
    /* and construct start pointers into coarsened edge array. */
    time = seconds();

    /* Construct mapping from original graph vtxs to coarsened graph vtxs. */
    cv2v_vals = smalloc(nvtxs * sizeof(int));
    cv2v_ptrs = smalloc((cnvtxs + 2) * sizeof(int));
    makecv2v(nvtxs, cnvtxs, v2cv, cv2v_vals, cv2v_ptrs);

    /* Compute an upper bound on the number of coarse graph edges. */
    cnedges = nedges - (nvtxs - cnvtxs);

    /* Now allocate space for the new graph.  Overallocate and realloc later. */
    *pcgraph = cgraph = smalloc((cnvtxs + 1) * sizeof(struct vtx_data *));
    links = smalloc(cnvtxs * sizeof(struct vtx_data));

    size = 2 * cnedges + cnvtxs;
    edges = smalloc(size * sizeof(int));
    if (COARSEN_EWGTS) {
	ewptr = eweights = smalloc(size * sizeof(float));
    }

    /* Zero all the seen flags. */
    seenflag = smalloc((cnvtxs + 1) * sizeof(int));
    sptr = seenflag;
    for (i = cnvtxs; i; i--) {
	*(++sptr) = 0;
    }

    /* Use the renumbering to fill in the edge lists for the new graph. */
    cnedges = 0;
    eptr = edges;
    ewgt = 1;

    sptr = cv2v_vals;
    for (cvtx = 1; cvtx <= cnvtxs; cvtx++) {
	nseen = 1;

	cgptr = cgraph[cvtx] = links++;

	if (COARSEN_VWGTS)
	    cgptr->vwgt = 0;
	else
	    cgptr->vwgt = 1;

	eptr[0] = cvtx;
	cgptr->edges = eptr;
	if (COARSEN_EWGTS) {
	    cgptr->ewgts = ewptr;
	}
	else
	    cgptr->ewgts = NULL;

	ewgt_sum = 0;
	for (i = cv2v_ptrs[cvtx + 1] - cv2v_ptrs[cvtx]; i; i--) {
	    vtx = *sptr++;

	    iptr = graph[vtx]->edges;
	    if (using_ewgts)
		fptr = graph[vtx]->ewgts;
	    for (j = graph[vtx]->nedges - 1; j; j--) {
		neighbor = *(++iptr);
		cneighbor = v2cv[neighbor];
		if (cneighbor != cvtx) {
		    if (using_ewgts)
			ewgt = *(++fptr);
		    ewgt_sum += ewgt;

		    /* Seenflags being used as map from cvtx to index. */
		    if (seenflag[cneighbor] == 0) {	/* New neighbor. */
			cgptr->edges[nseen] = cneighbor;
			if (COARSEN_EWGTS)
			    cgptr->ewgts[nseen] = ewgt;
			seenflag[cneighbor] = nseen++;
		    }
		    else {	/* Already seen neighbor. */
			if (COARSEN_EWGTS)
			    cgptr->ewgts[seenflag[cneighbor]] += ewgt;
		    }
		}
		else if (using_ewgts)
		    ++fptr;
	    }
	}

	/* Now clear the seenflag values. */
	iptr = cgptr->edges;
	for (j = nseen - 1; j; j--) {
	    seenflag[*(++iptr)] = 0;
	}

	if (COARSEN_EWGTS)
	    cgptr->ewgts[0] = -ewgt_sum;
	/* Increment pointers into edges list. */
	cgptr->nedges = nseen;
	eptr += nseen;
	if (COARSEN_EWGTS) {
	    ewptr += nseen;
	}

	cnedges += nseen - 1;
    }

    sfree(seenflag);

    /* Form new vertex weights by adding those from contracted edges. */
    if (COARSEN_VWGTS) {
	gptr = graph;
	for (i = 1; i <= nvtxs; i++) {
	    cgraph[v2cv[i]]->vwgt += (*(++gptr))->vwgt;
	}
    }

    /* Reduce arrays to actual sizes */
    cnedges /= 2;
    size = 2 * cnedges + cnvtxs;
    eptr = edges;
    edges = srealloc(edges, size * sizeof(int));
    if (eptr != edges) {        /* Need to reset pointers in graph. */
        for (i = 1; i <= cnvtxs; i++) {
            cgraph[i]->edges = edges;
            edges += cgraph[i]->nedges;
        }
    }

    if (COARSEN_EWGTS) {
	ewptr = eweights;
	eweights = srealloc(eweights, size * sizeof(float));
        if (ewptr != eweights) {        /* Need to reset pointers in graph. */
            for (i = 1; i <= cnvtxs; i++) {
                cgraph[i]->ewgts = eweights;
                eweights += cgraph[i]->nedges;
            }
        }
    }

    /* If desired, make new vtx coordinates = center-of-mass of their parents. */
    if (coords != NULL && ccoords != NULL && igeom > 0) {
	makeccoords(graph, cnvtxs, cv2v_ptrs, cv2v_vals,
		    igeom, coords, ccoords);
    }

    *pcnedges = cnedges;

    sfree(cv2v_ptrs);
    sfree(cv2v_vals);

    if (DEBUG_COARSEN > 0) {
	printf(" Coarse graph has %d vertices and %d edges\n", cnvtxs, cnedges);
    }

    make_cgraph_time += seconds() - time;
}