Package org.jgrapht.generate
Class NamedGraphGenerator<V,E>
- java.lang.Object
-
- org.jgrapht.generate.NamedGraphGenerator<V,E>
-
- Type Parameters:
V
- graph vertex typeE
- graph edge type
public class NamedGraphGenerator<V,E> extends java.lang.Object
Collection of commonly used named graphs- Author:
- Joris Kinable
-
-
Constructor Summary
Constructors Constructor Description NamedGraphGenerator()
Constructs a new generator for named graphs
-
Method Summary
-
-
-
Method Detail
-
doyleGraph
public static Graph<java.lang.Integer,DefaultEdge> doyleGraph()
Generate the Doyle Graph- Returns:
- Doyle Graph
- See Also:
generateDoyleGraph(org.jgrapht.Graph<V, E>)
-
generateDoyleGraph
public void generateDoyleGraph(Graph<V,E> targetGraph)
Generates a Doyle Graph. The Doyle graph, sometimes also known as the Holt graph (Marušič et al. 2005), is the quartic symmetric graph on 27 nodes- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
generalizedPetersenGraph
public static Graph<java.lang.Integer,DefaultEdge> generalizedPetersenGraph(int n, int k)
- Parameters:
n
- Generalized Petersen graphs $GP(n,k)$k
- Generalized Petersen graphs $GP(n,k)$- Returns:
- Generalized Petersen Graph
- See Also:
GeneralizedPetersenGraphGenerator
-
petersenGraph
public static Graph<java.lang.Integer,DefaultEdge> petersenGraph()
- Returns:
- Petersen Graph
- See Also:
generatePetersenGraph(org.jgrapht.Graph<V, E>)
-
generatePetersenGraph
public void generatePetersenGraph(Graph<V,E> targetGraph)
Generates a Petersen Graph. The Petersen Graph is a named graph that consists of 10 vertices and 15 edges, usually drawn as a five-point star embedded in a pentagon. It is the generalized Petersen graph $GP(5,2)$- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
dürerGraph
public static Graph<java.lang.Integer,DefaultEdge> dürerGraph()
- Returns:
- Dürer Graph
- See Also:
generateDürerGraph(org.jgrapht.Graph<V, E>)
-
generateDürerGraph
public void generateDürerGraph(Graph<V,E> targetGraph)
Generates a Dürer Graph. The Dürer graph is the skeleton of Dürer's solid, which is the generalized Petersen graph $GP(6,2)$.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
dodecahedronGraph
public static Graph<java.lang.Integer,DefaultEdge> dodecahedronGraph()
- Returns:
- Dodecahedron Graph
- See Also:
generateDodecahedronGraph(org.jgrapht.Graph<V, E>)
-
generateDodecahedronGraph
public void generateDodecahedronGraph(Graph<V,E> targetGraph)
Generates a Dodecahedron Graph. The skeleton of the dodecahedron (the vertices and edges) form a graph. It is one of 5 Platonic graphs, each a skeleton of its Platonic solid. It is the generalized Petersen graph $GP(10,2)$- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
desarguesGraph
public static Graph<java.lang.Integer,DefaultEdge> desarguesGraph()
- Returns:
- Desargues Graph
- See Also:
generateDesarguesGraph(org.jgrapht.Graph<V, E>)
-
generateDesarguesGraph
public void generateDesarguesGraph(Graph<V,E> targetGraph)
Generates a Desargues Graph. The Desargues graph is a cubic symmetric graph distance-regular graph on 20 vertices and 30 edges. It is the generalized Petersen graph $GP(10,3)$- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
nauruGraph
public static Graph<java.lang.Integer,DefaultEdge> nauruGraph()
- Returns:
- Nauru Graph
- See Also:
generateNauruGraph(org.jgrapht.Graph<V, E>)
-
generateNauruGraph
public void generateNauruGraph(Graph<V,E> targetGraph)
Generates a Nauru Graph. The Nauru graph is a symmetric bipartite cubic graph with 24 vertices and 36 edges. It is the generalized Petersen graph $GP(12,5)$- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
möbiusKantorGraph
public static Graph<java.lang.Integer,DefaultEdge> möbiusKantorGraph()
- Returns:
- Möbius-Kantor Graph
- See Also:
generateMöbiusKantorGraph(org.jgrapht.Graph<V, E>)
-
generateMöbiusKantorGraph
public void generateMöbiusKantorGraph(Graph<V,E> targetGraph)
Generates a Möbius-Kantor Graph. The unique cubic symmetric graph on 16 nodes. It is the generalized Petersen graph $GP(8,3)$- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
bullGraph
public static Graph<java.lang.Integer,DefaultEdge> bullGraph()
- Returns:
- Bull Graph
- See Also:
generateBullGraph(org.jgrapht.Graph<V, E>)
-
generateBullGraph
public void generateBullGraph(Graph<V,E> targetGraph)
Generates a Bull Graph. The bull graph is a simple graph on 5 nodes and 5 edges whose name derives from its resemblance to a schematic illustration of a bull or ram- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
butterflyGraph
public static Graph<java.lang.Integer,DefaultEdge> butterflyGraph()
- Returns:
- Butterfly Graph
- See Also:
generateButterflyGraph(org.jgrapht.Graph<V, E>)
-
generateButterflyGraph
public void generateButterflyGraph(Graph<V,E> targetGraph)
Generates a Butterfly Graph. This graph is also known as the "bowtie graph" (West 2000, p. 12). It is isomorphic to the friendship graph $F_2$.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
clawGraph
public static Graph<java.lang.Integer,DefaultEdge> clawGraph()
- Returns:
- Claw Graph
- See Also:
generateClawGraph(org.jgrapht.Graph<V, E>)
-
generateClawGraph
public void generateClawGraph(Graph<V,E> targetGraph)
Generates a Claw Graph. The complete bipartite graph $K_{1,3}$ is a tree known as the "claw."- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
buckyBallGraph
public static Graph<java.lang.Integer,DefaultEdge> buckyBallGraph()
- Returns:
- Bucky ball Graph
- See Also:
generateBuckyBallGraph(org.jgrapht.Graph<V, E>)
-
generateBuckyBallGraph
public void generateBuckyBallGraph(Graph<V,E> targetGraph)
Generates a Bucky ball Graph. This graph is a 3-regular 60-vertex planar graph. Its vertices and edges correspond precisely to the carbon atoms and bonds in buckminsterfullerene. When embedded on a sphere, its 12 pentagon and 20 hexagon faces are arranged exactly as the sections of a soccer ball.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
clebschGraph
public static Graph<java.lang.Integer,DefaultEdge> clebschGraph()
- Returns:
- Clebsch Graph
- See Also:
generateClebschGraph(org.jgrapht.Graph<V, E>)
-
generateClebschGraph
public void generateClebschGraph(Graph<V,E> targetGraph)
Generates a Clebsch Graph. The Clebsch graph, also known as the Greenwood-Gleason graph (Read and Wilson, 1998, p. 284), is a strongly regular quintic graph on 16 vertices and 40 edges.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
grötzschGraph
public static Graph<java.lang.Integer,DefaultEdge> grötzschGraph()
- Returns:
- Grötzsch Graph
- See Also:
generateGrötzschGraph(org.jgrapht.Graph<V, E>)
-
generateGrötzschGraph
public void generateGrötzschGraph(Graph<V,E> targetGraph)
Generates a Grötzsch Graph. The Grötzsch graph is smallest triangle-free graph with chromatic number four.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
bidiakisCubeGraph
public static Graph<java.lang.Integer,DefaultEdge> bidiakisCubeGraph()
- Returns:
- Bidiakis cube Graph
- See Also:
generateBidiakisCubeGraph(org.jgrapht.Graph<V, E>)
-
generateBidiakisCubeGraph
public void generateBidiakisCubeGraph(Graph<V,E> targetGraph)
Generates a Bidiakis cube Graph. The 12-vertex graph consisting of a cube in which two opposite faces (say, top and bottom) have edges drawn across them which connect the centers of opposite sides of the faces in such a way that the orientation of the edges added on top and bottom are perpendicular to each other.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
blanusaFirstSnarkGraph
public static Graph<java.lang.Integer,DefaultEdge> blanusaFirstSnarkGraph()
- Returns:
- First Blanusa Snark Graph
- See Also:
generateBlanusaFirstSnarkGraph(org.jgrapht.Graph<V, E>)
-
generateBlanusaFirstSnarkGraph
public void generateBlanusaFirstSnarkGraph(Graph<V,E> targetGraph)
Generates the First Blanusa Snark Graph. The Blanusa graphs are two snarks on 18 vertices and 27 edges.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
blanusaSecondSnarkGraph
public static Graph<java.lang.Integer,DefaultEdge> blanusaSecondSnarkGraph()
- Returns:
- Second Blanusa Snark Graph
- See Also:
generateBlanusaSecondSnarkGraph(org.jgrapht.Graph<V, E>)
-
generateBlanusaSecondSnarkGraph
public void generateBlanusaSecondSnarkGraph(Graph<V,E> targetGraph)
Generates the Second Blanusa Snark Graph. The Blanusa graphs are two snarks on 18 vertices and 27 edges.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
doubleStarSnarkGraph
public static Graph<java.lang.Integer,DefaultEdge> doubleStarSnarkGraph()
- Returns:
- Double Star Snark Graph
- See Also:
generateDoubleStarSnarkGraph(org.jgrapht.Graph<V, E>)
-
generateDoubleStarSnarkGraph
public void generateDoubleStarSnarkGraph(Graph<V,E> targetGraph)
Generates the Double Star Snark Graph. A snark on 30 vertices with edge chromatic number 4.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
brinkmannGraph
public static Graph<java.lang.Integer,DefaultEdge> brinkmannGraph()
- Returns:
- Brinkmann Graph
- See Also:
generateBrinkmannGraph(org.jgrapht.Graph<V, E>)
-
generateBrinkmannGraph
public void generateBrinkmannGraph(Graph<V,E> targetGraph)
Generates the Brinkmann Graph. The Brinkmann graph is a weakly regular quartic graph on 21 vertices and 42 edges.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
gossetGraph
public static Graph<java.lang.Integer,DefaultEdge> gossetGraph()
- Returns:
- Gosset Graph
- See Also:
generateGossetGraph(org.jgrapht.Graph<V, E>)
-
generateGossetGraph
public void generateGossetGraph(Graph<V,E> targetGraph)
Generates the Gosset Graph. The Gosset graph is a 27-regular graph on 56 vertices which is the skeleton of the Gosset polytope $3_{21}$.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
chvatalGraph
public static Graph<java.lang.Integer,DefaultEdge> chvatalGraph()
- Returns:
- Chvatal Graph
- See Also:
generateChvatalGraph(org.jgrapht.Graph<V, E>)
-
generateChvatalGraph
public void generateChvatalGraph(Graph<V,E> targetGraph)
Generates the Chvatal Graph. The Chvátal graph is an undirected graph with 12 vertices and 24 edges, discovered by Václav Chvátal (1970)- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
kittellGraph
public static Graph<java.lang.Integer,DefaultEdge> kittellGraph()
- Returns:
- Kittell Graph
- See Also:
generateKittellGraph(org.jgrapht.Graph<V, E>)
-
generateKittellGraph
public void generateKittellGraph(Graph<V,E> targetGraph)
Generates the Kittell Graph. The Kittell graph is a planar graph on 23 nodes and 63 edges that tangles the Kempe chains in Kempe's algorithm and thus provides an example of how Kempe's supposed proof of the four-color theorem fails.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
coxeterGraph
public static Graph<java.lang.Integer,DefaultEdge> coxeterGraph()
- Returns:
- Coxeter Graph
- See Also:
generateCoxeterGraph(org.jgrapht.Graph<V, E>)
-
generateCoxeterGraph
public void generateCoxeterGraph(Graph<V,E> targetGraph)
Generates the Coxeter Graph. The Coxeter graph is a nonhamiltonian cubic symmetric graph on 28 vertices and 42 edges.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
diamondGraph
public static Graph<java.lang.Integer,DefaultEdge> diamondGraph()
- Returns:
- Diamond Graph
- See Also:
generateDiamondGraph(org.jgrapht.Graph<V, E>)
-
generateDiamondGraph
public void generateDiamondGraph(Graph<V,E> targetGraph)
Generates the Diamond Graph. The Diamond graph has 4 vertices and 5 edges.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
ellinghamHorton54Graph
public static Graph<java.lang.Integer,DefaultEdge> ellinghamHorton54Graph()
- Returns:
- Ellingham-Horton 54 Graph
- See Also:
generateEllinghamHorton54Graph(org.jgrapht.Graph<V, E>)
-
generateEllinghamHorton54Graph
public void generateEllinghamHorton54Graph(Graph<V,E> targetGraph)
Generates the Ellingham-Horton 54 Graph. The Ellingham–Horton graph is a 3-regular bicubic graph of 54 vertices- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
ellinghamHorton78Graph
public static Graph<java.lang.Integer,DefaultEdge> ellinghamHorton78Graph()
- Returns:
- Ellingham-Horton 78 Graph
- See Also:
generateEllinghamHorton78Graph(org.jgrapht.Graph<V, E>)
-
generateEllinghamHorton78Graph
public void generateEllinghamHorton78Graph(Graph<V,E> targetGraph)
Generates the Ellingham-Horton 78 Graph. The Ellingham–Horton graph is a 3-regular graph of 78 vertices- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
erreraGraph
public static Graph<java.lang.Integer,DefaultEdge> erreraGraph()
- Returns:
- Errera Graph
- See Also:
generateErreraGraph(org.jgrapht.Graph<V, E>)
-
generateErreraGraph
public void generateErreraGraph(Graph<V,E> targetGraph)
Generates the Errera Graph. The Errera graph is the 17-node planar graph- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
folkmanGraph
public static Graph<java.lang.Integer,DefaultEdge> folkmanGraph()
- Returns:
- Folkman Graph
- See Also:
generateFolkmanGraph(org.jgrapht.Graph<V, E>)
-
generateFolkmanGraph
public void generateFolkmanGraph(Graph<V,E> targetGraph)
Generates the Folkman Graph. The Folkman graph is the 20-vertex 4-regular graph.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
franklinGraph
public static Graph<java.lang.Integer,DefaultEdge> franklinGraph()
- Returns:
- Franklin Graph
- See Also:
generateFranklinGraph(org.jgrapht.Graph<V, E>)
-
generateFranklinGraph
public void generateFranklinGraph(Graph<V,E> targetGraph)
Generates the Franklin Graph. The Franklin graph is the 12-vertex cubic graph.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
fruchtGraph
public static Graph<java.lang.Integer,DefaultEdge> fruchtGraph()
- Returns:
- Frucht Graph
- See Also:
generateFruchtGraph(org.jgrapht.Graph<V, E>)
-
generateFruchtGraph
public void generateFruchtGraph(Graph<V,E> targetGraph)
Generates the Frucht Graph. The Frucht graph is smallest cubic identity graph.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
goldnerHararyGraph
public static Graph<java.lang.Integer,DefaultEdge> goldnerHararyGraph()
- Returns:
- Goldner-Harary Graph
- See Also:
generateGoldnerHararyGraph(org.jgrapht.Graph<V, E>)
-
generateGoldnerHararyGraph
public void generateGoldnerHararyGraph(Graph<V,E> targetGraph)
Generates the Goldner-Harary Graph. The Goldner-Harary graph is a graph on 11 vertices and 27. It is a simplicial graph, meaning that it is polyhedral and consists of only triangular faces.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
heawoodGraph
public static Graph<java.lang.Integer,DefaultEdge> heawoodGraph()
- Returns:
- Heawood Graph
- See Also:
generateHeawoodGraph(org.jgrapht.Graph<V, E>)
-
generateHeawoodGraph
public void generateHeawoodGraph(Graph<V,E> targetGraph)
Generates the Heawood Graph. Heawood graph is an undirected graph with 14 vertices and 21 edges, named after Percy John Heawood.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
herschelGraph
public static Graph<java.lang.Integer,DefaultEdge> herschelGraph()
- Returns:
- Herschel Graph
- See Also:
generateHerschelGraph(org.jgrapht.Graph<V, E>)
-
generateHerschelGraph
public void generateHerschelGraph(Graph<V,E> targetGraph)
Generates the Herschel Graph. The Herschel graph is the smallest nonhamiltonian polyhedral graph (Coxeter 1973, p. 8). It is the unique such graph on 11 nodes and 18 edges.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
hoffmanGraph
public static Graph<java.lang.Integer,DefaultEdge> hoffmanGraph()
- Returns:
- Hoffman Graph
- See Also:
generateHoffmanGraph(org.jgrapht.Graph<V, E>)
-
generateHoffmanGraph
public void generateHoffmanGraph(Graph<V,E> targetGraph)
Generates the Hoffman Graph. The Hoffman graph is the bipartite graph on 16 nodes and 32 edges.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
krackhardtKiteGraph
public static Graph<java.lang.Integer,DefaultEdge> krackhardtKiteGraph()
- Returns:
- Krackhardt kite Graph
- See Also:
generateKrackhardtKiteGraph(org.jgrapht.Graph<V, E>)
-
generateKrackhardtKiteGraph
public void generateKrackhardtKiteGraph(Graph<V,E> targetGraph)
Generates the Krackhardt kite Graph. The Krackhardt kite is the simple graph on 10 nodes and 18 edges. It arises in social network theory.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
klein3RegularGraph
public static Graph<java.lang.Integer,DefaultEdge> klein3RegularGraph()
- Returns:
- Klein 3-regular Graph
- See Also:
generateKlein3RegularGraph(org.jgrapht.Graph<V, E>)
-
generateKlein3RegularGraph
public void generateKlein3RegularGraph(Graph<V,E> targetGraph)
Generates the Klein 3-regular Graph. This graph is a 3-regular graph with 56 vertices and 84 edges, named after Felix Klein.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
klein7RegularGraph
public static Graph<java.lang.Integer,DefaultEdge> klein7RegularGraph()
- Returns:
- Klein 7-regular Graph
- See Also:
generateKlein7RegularGraph(org.jgrapht.Graph<V, E>)
-
generateKlein7RegularGraph
public void generateKlein7RegularGraph(Graph<V,E> targetGraph)
Generates the Klein 7-regular Graph. This graph is a 7-regular graph with 24 vertices and 84 edges, named after Felix Klein.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
moserSpindleGraph
public static Graph<java.lang.Integer,DefaultEdge> moserSpindleGraph()
- Returns:
- Moser spindle Graph
- See Also:
generateMoserSpindleGraph(org.jgrapht.Graph<V, E>)
-
generateMoserSpindleGraph
public void generateMoserSpindleGraph(Graph<V,E> targetGraph)
Generates the Moser spindle Graph. The Moser spindle is the 7-node unit-distance graph.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
pappusGraph
public static Graph<java.lang.Integer,DefaultEdge> pappusGraph()
- Returns:
- Pappus Graph
- See Also:
generatePappusGraph(org.jgrapht.Graph<V, E>)
-
generatePappusGraph
public void generatePappusGraph(Graph<V,E> targetGraph)
Generates the Pappus Graph. The Pappus Graph is a bipartite 3-regular undirected graph with 18 vertices and 27 edges.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
poussinGraph
public static Graph<java.lang.Integer,DefaultEdge> poussinGraph()
- Returns:
- Poussin Graph
- See Also:
generatePoussinGraph(org.jgrapht.Graph<V, E>)
-
generatePoussinGraph
public void generatePoussinGraph(Graph<V,E> targetGraph)
Generates the Poussin Graph. The Poussin graph is the 15-node planar graph.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
schläfliGraph
public static Graph<java.lang.Integer,DefaultEdge> schläfliGraph()
- Returns:
- Schläfli Graph
- See Also:
generateSchläfliGraph(org.jgrapht.Graph<V, E>)
-
generateSchläfliGraph
public void generateSchläfliGraph(Graph<V,E> targetGraph)
Generates the Schläfli Graph. The Schläfli graph is a strongly regular graph on 27 nodes- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
tietzeGraph
public static Graph<java.lang.Integer,DefaultEdge> tietzeGraph()
- Returns:
- Tietze Graph
- See Also:
generateTietzeGraph(org.jgrapht.Graph<V, E>)
-
generateTietzeGraph
public void generateTietzeGraph(Graph<V,E> targetGraph)
Generates the Tietze Graph. The Tietze Graph is an undirected cubic graph with 12 vertices and 18 edges.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
thomsenGraph
public static Graph<java.lang.Integer,DefaultEdge> thomsenGraph()
- Returns:
- Thomsen Graph
- See Also:
generateThomsenGraph(org.jgrapht.Graph<V, E>)
-
generateThomsenGraph
public void generateThomsenGraph(Graph<V,E> targetGraph)
Generates the Thomsen Graph. The Thomsen Graph is complete bipartite graph consisting of 6 vertices (3 vertices in each bipartite partition. It is also called the Utility graph.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
tutteGraph
public static Graph<java.lang.Integer,DefaultEdge> tutteGraph()
- Returns:
- Tutte Graph
- See Also:
generateTutteGraph(org.jgrapht.Graph<V, E>)
-
generateTutteGraph
public void generateTutteGraph(Graph<V,E> targetGraph)
Generates the Tutte Graph. The Tutte Graph is a 3-regular graph with 46 vertices and 69 edges.- Parameters:
targetGraph
- receives the generated edges and vertices; if this is non-empty on entry, the result will be a disconnected graph since generated elements will not be connected to existing elements
-
-