| Package | Description |
|---|---|
| graph.algorithm.cycles |
Classes for detecting cycles and finding a cycle basis of directed and undirected graphs.
|
| graph.algorithms.connectivity |
Classes related to the planar augmentation problem.
|
| graph.algorithms.drawing |
Implementations of various graph drawing algorithms.
|
| graph.algorithms.lrpartition |
Classes related to LR partitions.
|
| graph.algorithms.numbering |
Classes represent different numberings of vertices.
|
| graph.algorithms.planarity |
Implementations of different planarity testing algorithms.
|
| graph.algorithms.planarity.dual |
Classes represent dual graph and its elements.
|
| graph.elements |
Basic graph elements.
|
| graph.layout |
Layouters which are invoked in order to lay out graphs.
|
| graph.layout.automatic |
Classes for laying graphs automatically, based on their properties.
|
| graph.layout.box |
Simple layouter which places vertices on a table like structure.
|
| graph.layout.circle |
Layouters which use different circular layout algorithms.
|
| graph.layout.orthogonal |
Layouters which use orthogonal drawing algorithms.
|
| graph.layout.straight.line |
Layouters which call different straight-line graph drawing algorithms.
|
| graph.layout.symmetric |
Layouters which call different symmetric graph drawing algorithms.
|
| graph.math |
Classes containing various mathematical calculations and mathematical objects.
|
| graph.operations |
Classes containing certain mathematical calculations involving two graphs,
like their unions.
|
| graph.ordering |
Classes implementing different orderings of graph vertices.
|
| graph.ordering.circular |
Classes including an implementation of the algorithm CIRCULAR and necessary helper classes.
|
| graph.properties |
Classes containing methods for checking different properties of the given graph.
|
| graph.properties.components |
Classes representing split components and other elements associated with them, such as separation pairs.
|
| graph.properties.splitting |
Implementations of algorithms for splitting graph into bi- and triconnected components.
|
| graph.symmetry |
Classes related to graph's symmetries and automorphisms.
|
| graph.symmetry.nauty |
Classes needed to implement McKay's graph labeling algorithm.
|
| graph.traversal |
Classes implementing different graph traversal algorithms, like DFS and Dijkstra's shortest path.
|
| graph.tree.bc |
Classes representing a BC-tree and its elements.
|
| graph.tree.binary |
Classes representing a binary-tree and its elements.
|
| graph.tree.pq |
Classes representing a PQ-tree and its elements.
|
| graph.tree.spqr |
Classes representing a SPQR-tree and its elements.
|
| graph.trees.dfs |
Contains a class which represents a DFS tree.
|
| graph.util |
Helper classes.
|
| Modifier and Type | Method and Description |
|---|---|
java.util.List<java.util.List<V>> |
SimpleCyclesFinder.findCycles(Graph<V,E> graph)
Finds cycle basis of the given graph.
|
| Constructor and Description |
|---|
JohnsonSimpleCycles(Graph<V,E> graph) |
JohnsonSimpleCycles(Graph<V,E> graph,
boolean stopWhenOneFound)
Create a simple cycle finder for the specified graph.
|
PatonSimpleCycles(Graph<V,E> graph)
Create a cycle basis finder for the specified graph.
|
SimpleUndirectedCyclesFinder(Graph<V,E> graph) |
| Modifier and Type | Method and Description |
|---|---|
java.util.List<Graph<V,E>> |
PlanarAugmentationLabel.getChildren() |
| Modifier and Type | Method and Description |
|---|---|
void |
PlanarAugmentationLabel.addChild(Graph<V,E> pendant)
Adds child pendant to the label
|
java.util.List<E> |
PlanarAugmentation.planarBiconnected(Graph<V,E> graph)
Finds edges which need to be added in order to transform the graph into a planar
biconnected one.
|
| Modifier and Type | Method and Description |
|---|---|
void |
PlanarAugmentationLabel.setChildren(java.util.List<Graph<V,E>> children) |
| Constructor and Description |
|---|
ConvexDrawing(Graph<V,E> graph) |
CyclicSymmetricGraphDrawing(Graph<V,E> graph) |
PlanarConvexEmbedding(Graph<V,E> graph) |
TutteEmbedding(Graph<V,E> graph) |
VisibilityRepresentation(Graph<V,E> graph) |
| Constructor and Description |
|---|
LRPartition(Graph<V,E> graph) |
| Modifier and Type | Method and Description |
|---|---|
void |
STNumbering.formOrder(Graph<V,E> graph,
V s,
V t)
Forms the st-order
|
| Constructor and Description |
|---|
DFSNumbering(Graph<V,E> graph) |
STNumbering(Graph<V,E> graph,
V s,
V t) |
| Modifier and Type | Method and Description |
|---|---|
Graph<V,E> |
MaximumPlanaritySubgraph.calculateMaximumPlanarityGraph() |
Graph<V,E> |
MaximumPlanaritySubgraph.getPlanarSubgraph() |
| Modifier and Type | Method and Description |
|---|---|
static <V extends Vertex,E extends Edge<V>> |
PlanarEmbedding.emedGraph(Graph<V,E> graph,
V s,
V t)
Calculates a planar embedding of a graph based on the work of Chiba, Nishizeki, Abe and Ozava
A linear algorithm for embedding planar graphs using PQ-trees, Journal of Computer and System Sciences 30, 1985
|
boolean |
PQTreePlanarity.isPlannar(Graph<V,E> graph) |
abstract boolean |
PlanarityTestingAlgorithm.isPlannar(Graph<V,E> graph)
Determines if the graph is planar
|
boolean |
FraysseixMendezPlanarity.isPlannar(Graph<V,E> graph) |
boolean |
BoyerMyrvoldPlanarity.isPlannar(Graph<V,E> graph) |
| Constructor and Description |
|---|
MaximumPlanaritySubgraph(Graph<V,E> graph) |
PlanarFaces(Graph<V,E> graph) |
PlanarFaces(Graph<V,E> graph,
STNumbering<V,E> stNumbering) |
| Modifier and Type | Class and Description |
|---|---|
class |
STDualGraph<V extends Vertex,E extends Edge<V>>
Constructs a st-dual graph
Given a planar st-graph G, the dual planar st-graph G = (V, E)
is a digraph with the following properties:
- V* is the set of faces in G with the addition that the external face (s, .
|
| Constructor and Description |
|---|
STDualGraph(Graph<V,E> graph,
java.util.List<E> externalFace,
V s,
V t)
Construct the st-dual graph given a graph, external face and s and t vertices
|
| Modifier and Type | Method and Description |
|---|---|
Graph<V,E> |
Graph.subgraph(java.util.List<V> subgraphVertices)
Creates a subgraph of the graph containing the
given vertices
|
| Modifier and Type | Method and Description |
|---|---|
java.util.List<Graph<V,E>> |
Graph.listBiconnectedComponents()
Finds all biconnected components of the graph
|
| Constructor and Description |
|---|
VertexDegreeComparator(Graph<V,E> graph) |
| Modifier and Type | Method and Description |
|---|---|
static GraphLayoutProperties |
DefaultGraphLayoutProperties.getDefaultLayoutProperties(LayoutAlgorithms algorithm,
Graph<?,?> graph)
Sets default layout properties of the algorithm given a graph
|
Drawing<V,E> |
AbstractPrefuseLayouter.layout(Graph<V,E> graph,
GraphLayoutProperties layoutProperties) |
abstract Drawing<V,E> |
AbstractLayouter.layout(Graph<V,E> graph,
GraphLayoutProperties layoutProperties)
Lays out the graph, taking into account given properties
|
Drawing<V,E> |
AbstractJungLayouter.layout(Graph<V,E> graph,
GraphLayoutProperties layoutProperties) |
Drawing<V,E> |
AbstractJGraphXLayouter.layout(Graph<V,E> graph,
GraphLayoutProperties layoutProperties) |
| Modifier and Type | Method and Description |
|---|---|
Drawing<V,E> |
AutomaticPropertiesLayout.layout(Graph<V,E> graph,
GraphLayoutProperties layoutProperties) |
LayoutAlgorithms |
LayoutPicker.pickAlgorithm(Graph<V,E> graph)
Picks the appropriate algorithm based on the properties of the graph
|
| Modifier and Type | Method and Description |
|---|---|
Drawing<V,E> |
BoxLayouter.layout(Graph<V,E> graph,
GraphLayoutProperties layoutProperties) |
| Modifier and Type | Method and Description |
|---|---|
Drawing<V,E> |
CircleWithCenterLayouter.layout(Graph<V,E> graph,
GraphLayoutProperties layoutProperties) |
Drawing<V,E> |
CircleLayouter.layout(Graph<V,E> graph,
GraphLayoutProperties layoutProperties) |
| Modifier and Type | Method and Description |
|---|---|
Drawing<V,E> |
VisibilityRepresentationLayout.layout(Graph<V,E> graph,
GraphLayoutProperties layoutProperties) |
| Modifier and Type | Method and Description |
|---|---|
Drawing<V,E> |
TutteLayouter.layout(Graph<V,E> graph,
GraphLayoutProperties layoutProperties) |
Drawing<V,E> |
ConvexLayouter.layout(Graph<V,E> graph,
GraphLayoutProperties layoutProperties) |
| Modifier and Type | Method and Description |
|---|---|
Drawing<V,E> |
SymmetricCircleLayouter.layout(Graph<V,E> graph,
GraphLayoutProperties layoutProperties) |
| Constructor and Description |
|---|
CzekanovskiDiceDistance(Graph<V,E> graph) |
| Modifier and Type | Method and Description |
|---|---|
Graph<V,E> |
GraphOperations.formCycleGraph(java.util.List<V> vertices,
java.lang.Class<?> edgeClass)
Forms a cycle from vertices v1...vn in that order
|
Graph<V,E> |
GraphOperations.removeEdgeFromGraph(Graph<V,E> graph,
E edge)
Removes an edge from the graph
|
Graph<V,E> |
GraphOperations.union(java.util.List<Graph<V,E>> graphs)
Finds a graph which is a union of the provided list of graphs
|
| Modifier and Type | Method and Description |
|---|---|
java.util.List<E> |
GraphOperations.edgesInCommon(Graph<V,E> graph1,
Graph<V,E> graph2)
Finds edges which the given two graphs have in common
|
java.util.List<E> |
GraphOperations.edgesInCommon(Graph<V,E> graph1,
Graph<V,E> graph2)
Finds edges which the given two graphs have in common
|
boolean |
GraphOperations.isProperSubgraph(Graph<V,E> supergraph,
Graph<V,E> subgraph)
Determines is one graph is a proper subraph of another one
H is a proper subgraph of G, if V(H)!=V(G) || E(H)!=E(G)
|
boolean |
GraphOperations.isProperSubgraph(Graph<V,E> supergraph,
Graph<V,E> subgraph)
Determines is one graph is a proper subraph of another one
H is a proper subgraph of G, if V(H)!=V(G) || E(H)!=E(G)
|
boolean |
GraphOperations.isSubgraph(Graph<V,E> supergraph,
Graph<V,E> subgraph)
Determines is one graph is a subgraph of another one
|
boolean |
GraphOperations.isSubgraph(Graph<V,E> supergraph,
Graph<V,E> subgraph)
Determines is one graph is a subgraph of another one
|
Graph<V,E> |
GraphOperations.removeEdgeFromGraph(Graph<V,E> graph,
E edge)
Removes an edge from the graph
|
java.util.List<V> |
GraphOperations.verticesInCommon(Graph<V,E> graph1,
Graph<V,E> graph2)
Finds vertices which the given two graphs have in common
|
java.util.List<V> |
GraphOperations.verticesInCommon(Graph<V,E> graph1,
Graph<V,E> graph2)
Finds vertices which the given two graphs have in common
|
| Modifier and Type | Method and Description |
|---|---|
Graph<V,E> |
GraphOperations.union(java.util.List<Graph<V,E>> graphs)
Finds a graph which is a union of the provided list of graphs
|
| Modifier and Type | Method and Description |
|---|---|
static <V extends Vertex,E extends Edge<V>> |
TopologicalOrdering.calculateOrdering(Graph<V,E> graph)
Finds the topological ordering
|
static <V extends Vertex,E extends Edge<V>> |
CanonicalOrdering.calculateOrdering(Graph<V,E> graph) |
| Modifier and Type | Class and Description |
|---|---|
class |
GraphCopy<V extends Vertex,E extends Edge<V>>
A graph containing triangulated edges.
|
| Constructor and Description |
|---|
Circular(Graph<V,E> graph) |
| Modifier and Type | Method and Description |
|---|---|
java.util.List<Graph<V,E>> |
GraphProperties.listBiconnectedComponents()
Finds all biconnected components of a graph
|
| Constructor and Description |
|---|
Bipartite(Graph<V,E> graph) |
GraphProperties(Graph<V,E> graph) |
| Modifier and Type | Class and Description |
|---|---|
class |
Block<V extends Vertex,E extends Edge<V>>
Class represent a block of a graph.
|
class |
SplitComponent<V extends Vertex,E extends Edge<V>>
Class represents a split component of a graph
|
| Modifier and Type | Method and Description |
|---|---|
Graph<V,E> |
SplitComponent.getGraph() |
Graph<V,E> |
Block.getGraph() |
| Modifier and Type | Method and Description |
|---|---|
void |
SplitComponent.setGraph(Graph<V,E> graph) |
void |
Block.setGraph(Graph<V,E> graph) |
| Constructor and Description |
|---|
Block(Graph<V,E> graph) |
SplitComponent(SplitPair<V,E> splitPair,
Graph<V,E> graph)
Constructs a split component of the provided split pair and graph
|
| Modifier and Type | Method and Description |
|---|---|
Graph<V,E> |
Splitting.splitGraph(java.util.List<SplitComponent<V,E>> splitComponents,
E edge)
A split graph of a split pair with respect of some edge
is the union of all split components which don't contain that edge
|
Graph<V,E> |
Splitting.splitGraph(SplitPair<V,E> splitPair,
E edge,
Graph<V,E> graph)
Finds a split graph with respect to the given split pair and edge
|
| Modifier and Type | Method and Description |
|---|---|
java.util.List<Graph<V,E>> |
BiconnectedSplitting.findBiconnectedComponents()
Divides the graph into biconnected components
and return them
|
| Modifier and Type | Method and Description |
|---|---|
java.util.List<V> |
Splitting.findAllCutVertices(Graph<V,E> graph)
Finds a list of graph's cut vertices
A cut vertex is a vertex whose removal would disconnect the remaining graph
|
java.util.List<SplitComponent<V,E>> |
Splitting.findAllSplitComponents(Graph<V,E> graph,
SplitPair<V,E> splitPair) |
java.util.List<SplitPair<V,E>> |
Splitting.findAllSplitPairs(Graph<V,E> graph)
Deprecated.
|
java.util.List<SplitPair<V,E>> |
SeparationPairSplitting.findSeaparationPairs(Graph<V,E> graph)
Finds all separation pairs of the given graph
|
java.util.List<SplitPair<V,E>> |
Splitting.maximalSplitPairs(Graph<V,E> graph,
E edge)
Finds a list of maximal split pair with respect to some edge
A maximal split pair with respect to some edge
is a split pair not dominated by any other split pair with respect to that edge
There may several such pairs
|
Graph<V,E> |
Splitting.splitGraph(SplitPair<V,E> splitPair,
E edge,
Graph<V,E> graph)
Finds a split graph with respect to the given split pair and edge
|
boolean |
Splitting.splitPairIsDominantedBy(Graph<V,E> graph,
SplitPair<V,E> dominanted,
SplitPair<V,E> dominant,
E edge)
Checks if one split pair is dominated by another given an edge
A split pair {u,v} is dominated by another split pair {x,y} if
|
| Constructor and Description |
|---|
BiconnectedSplitting(Graph<V,E> graph) |
HopcroftTarjanSplitting(Graph<V,E> graph) |
HopcroftTarjanSplitting(Graph<V,E> graph,
boolean debug) |
| Modifier and Type | Method and Description |
|---|---|
java.util.List<Pair<java.lang.Double,double[]>> |
DeFrayseeixHeuristic.calculate(Graph<V,E> graph)
Calculates the heuristic
|
| Constructor and Description |
|---|
PermutationAnalyzator(Graph<V,E> graph)
Given a graph, finds its permutations and intializes the permutations list
|
| Constructor and Description |
|---|
BinaryRepresentation(Graph<V,E> graph) |
McKayGraphLabelingAlgorithm(Graph<V,E> graph) |
| Modifier and Type | Method and Description |
|---|---|
static <V extends Vertex,E extends Edge<V>> |
GraphTraversal.findAllPathsDFS(Graph<V,E> graph,
V source,
V target)
Finds all paths in the given graph between two provided vertices using depth-first search
|
static <V extends Vertex,E extends Edge<V>> |
GraphTraversal.findAllPathsDFS(Graph<V,E> graph,
V source,
V target,
java.util.List<V> excluding)
Finds all paths in the given graph between two provided vertices not containing any of vertices in the given list using depth-first search
|
static <V extends Vertex,E extends Edge<V>> |
GraphTraversal.findAllPathsDFSContaining(Graph<V,E> graph,
V source,
V target,
java.util.List<V> containing)
Finds all paths in the given graph between two provided vertices containing a list of vertices using depth-first search
|
static <V extends Vertex,E extends Edge<V>> |
GraphTraversal.findLongestPath(Graph<V,E> graph)
Finds the longest path in a graph
Method should be rewritten to increase its effectiveness
|
static <V extends Vertex,E extends Edge<V>> |
GraphTraversal.nonrecursiveDFSPath(Graph<V,E> graph,
V source,
V target)
A non-recursive implementation of the depth-first search for finding a path between two vertices
More efficient than the recursive implementation
|
| Constructor and Description |
|---|
DFSTreeTraversal(Graph<V,E> graph) |
DijkstraAlgorithm(Graph<V,E> graph)
Initialized the algorithm's parameters based on the properties of the graph
|
| Modifier and Type | Class and Description |
|---|---|
class |
BCTree<V extends Vertex,E extends Edge<V>>
Class represents a block-cut vertex tree and contains methods for its construction given
a separable graph
Let B be the set of blocks and C be the set of cut vertices of a separable graph G.
|
| Modifier and Type | Method and Description |
|---|---|
java.util.List<Graph<V,E>> |
BCTree.getPendants() |
| Modifier and Type | Method and Description |
|---|---|
void |
BCTree.setPendants(java.util.List<Graph<V,E>> pendants) |
| Constructor and Description |
|---|
BCTree(Graph<V,E> graph)
Constructs the BC-tree of the specified graph
|
| Constructor and Description |
|---|
BinaryTree(Graph<V,E> graph)
Tried to construct the binary tree given a graph
|
| Modifier and Type | Class and Description |
|---|---|
class |
PQTree<V extends Vertex,E extends Edge<V>>
Class represents a PQ-tree, which is used in some algorithms for planarity testing
P nodes are cut vertices
Q nodes are nonseparable components
Leaves are virtual vertices (vertices on the other side of edges where one vertex is on subgraph Gk and the
other one is in V-Vk)
|
| Constructor and Description |
|---|
PQTree(Graph<V,E> graph,
java.util.List<E> virtualEdges,
java.util.Map<V,java.lang.Integer> stNumbering)
Construct the PQ tree, given the a graph, a list of virtual edges and st-numbering
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractTree<V extends Vertex,E extends Edge<V>>
Abstract class, extended by SPQR tree and proto SPQR tree
|
class |
ProtoSPQRTree<V extends Vertex,E extends Edge<V>>
Used in the construction of SPQR trees
Not a very efficient implementation, needs to be rewritten
Can be used for smaller graphs
|
class |
Skeleton<V extends Vertex,E extends Edge<V>>
Each node is associated with a special graph which is called a skeleton of the node
It is a simplified version of the original graph where some subgraphs were replaces
|
class |
SPQRTree<V extends Vertex,E extends Edge<V>>
SPQR-trees implicitly represent all embeddings of a graph
The triconnected components of a biconnected graph are a system of smaller graphs
that describe all of the 2-vertex cuts in the graph.
|
| Modifier and Type | Method and Description |
|---|---|
Graph<V,E> |
TreeEdgeWithContent.getContent() |
Graph<V,E> |
ProtoSPQRTree.getgPrim() |
Graph<V,E> |
ProtoSPQRTree.getGraph() |
| Modifier and Type | Method and Description |
|---|---|
void |
TreeEdgeWithContent.setContent(Graph<V,E> content) |
void |
ProtoSPQRTree.setgPrim(Graph<V,E> gPrim) |
void |
ProtoSPQRTree.setGraph(Graph<V,E> graph) |
| Constructor and Description |
|---|
AbstractTree(E referenceEdge,
Graph<V,E> graph)
Constructors which sets the reference edge and graph for which the tree is being constructed
|
ProtoSPQRTree(E referenceEdge,
Graph<V,E> graph) |
SPQRTree(E referenceEdge,
Graph<V,E> graph)
Constructs a SPQR tree of the given graph
|
SPQRTreeNode(NodeType nodeType,
Graph<V,E> skeleton)
Construct a SPQR tree node of the given type and sets its skeleton
|
TreeEdgeWithContent(V origin,
V destination,
Graph<V,E> content)
Constructs an edge between the given two vertices
|
| Modifier and Type | Class and Description |
|---|---|
class |
DFSTree<V extends Vertex,E extends Edge<V>>
DFS tree, with methods for its creation and relevant method
regarding its edges and nodes
|
| Modifier and Type | Method and Description |
|---|---|
static <V extends Vertex,E extends Edge<V>> |
Util.copyGraph(Graph<V,E> graph)
Creates a copy of a graph
|
| Modifier and Type | Method and Description |
|---|---|
static <V extends Vertex,E extends Edge<V>> |
Util.copyGraph(Graph<V,E> graph)
Creates a copy of a graph
|