salvo.jesus.graph.algorithm

Class GraphContractionAlgorithm

java.lang.Object

salvo.jesus.graph.algorithm.GraphContractionAlgorithm

public abstract class GraphContractionAlgorithm
extends Object

GraphContraction is an algorithm class for managing a series of contractions on a graph (directed or undirected). It is abstract because it requires a concrete subclass to supply certain rules about how the contraction should be performed. Note that GraphContraction modifies its input graph in place; it does not construct a new graph.

Author:

John V. Sichi

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	GraphContractionAlgorithm(Graph graph)

Method Summary

Modifier and Type	Method and Description
void	contractEdges(Collection edges) Perform contractVertexPair for the two incident vertices of each edge in a specified set.
void	contractVertexPair(Vertex vRemain, Vertex vRemove) Contract two arbitrary vertices within a graph.
void	contractVertices(Collection vertices) Contract an arbitrary collection of vertices within a graph into a single vertex.
protected abstract Edge	copyEdge(Edge oldEdge, Vertex vA, Vertex vB) Subclass method called to add a new contracted edge equivalent to oldEdge, but connecting vA to vB.
Edge	getContractionEdge(Edge edge) Find the resulting contraction for an Edge.
GraphComponent	getContractionResult(GraphComponent c) Find the resulting contraction for a GraphComponent (Vertex or Edge).
Vertex	getContractionVertex(Vertex v) Find the resulting contraction for a Vertex.
Graph	getGraph()
protected abstract boolean	shouldBeSelfLoop(Edge e) Subclass method called to decide whether a given edge encountered during contraction should be turned into a self-loop on the contracted vertex.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

GraphContractionAlgorithm

protected GraphContractionAlgorithm(Graph graph)

Method Detail

getGraph

public Graph getGraph()

Returns:

the graph on which this contraction operates

contractVertexPair

public void contractVertexPair(Vertex vRemain,
                               Vertex vRemove)
                        throws Exception

Contract two arbitrary vertices within a graph. The vertices need not be already connected.

Parameters:

vRemain - the vertex that will remain after contraction

vRemove - the vertex that will be removed by contraction

Throws:

Exception - if the graph cannot be modified

contractVertices

public void contractVertices(Collection vertices)
                      throws Exception

Contract an arbitrary collection of vertices within a graph into a single vertex. The vertices need not be already connected.

Parameters:

vertices - the vertices to be contracted; the first vertex returned by this Collection's iterator will be the one to remain

Throws:

Exception - if the graph cannot be modified

contractEdges

public void contractEdges(Collection edges)
                   throws Exception

Perform contractVertexPair for the two incident vertices of each edge in a specified set. For each edge, getVertexA() determines vRemain and getVertexB() determines vRemove.

Parameters:

edges - the edges to contract

Throws:

Exception - if the graph cannot be modified

getContractionVertex

public Vertex getContractionVertex(Vertex v)

Find the resulting contraction for a Vertex.

Parameters:

v - the Vertex to find the contraction for

Returns:

the contracted vertex (same as v if v has not been contracted)

getContractionEdge

public Edge getContractionEdge(Edge edge)

Find the resulting contraction for an Edge.

Parameters:

edge - the Edge to find the contraction for

Returns:

the contracted edge (same as edge if edge has not been contracted)

getContractionResult

public GraphComponent getContractionResult(GraphComponent c)

Find the resulting contraction for a GraphComponent (Vertex or Edge).

Parameters:

c - the GraphComponent

Returns:

the contracted component (same as c if c has not been contracted)

shouldBeSelfLoop

protected abstract boolean shouldBeSelfLoop(Edge e)

Subclass method called to decide whether a given edge encountered during contraction should be turned into a self-loop on the contracted vertex.

copyEdge

protected abstract Edge copyEdge(Edge oldEdge,
                                 Vertex vA,
                                 Vertex vB)
                          throws Exception

Subclass method called to add a new contracted edge equivalent to oldEdge, but connecting vA to vB. The rule may decide that oldEdge is already equivalent to an existing edge between vA and vB, in which case no new edge is added. If a new edge is created, the implementation should add it to getGraph().

Parameters:

oldEdge - the edge being contracted

vA - one vertex to which the new edge should be incident; for a DirectedGraph, this is the source

vB - the other vertex to which the new edge should be incident; for a DirectedGraph, this is the sink

Returns:

the new or existing edge

Throws:

Exception - if the graph cannot be modified