NamedGraphGenerator (JGraphT : a free Java graph library)

java.lang.Object
- org.jgrapht.generate.NamedGraphGenerator<V,E>

Type Parameters:

V - graph vertex type

E - graph edge type
```
public class NamedGraphGenerator<V,E>
extends Object
```
Collection of commonly used named graphs

Author:

Joris Kinable

Constructor Summary

Constructors
Constructor and Description

NamedGraphGenerator()
Constructs a new generator for named graphs

Constructors
Constructor and Description
`NamedGraphGenerator()` Constructs a new generator for named graphs

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static Graph<Integer,DefaultEdge>`	`bidiakisCubeGraph()`
`static Graph<Integer,DefaultEdge>`	`blanusaFirstSnarkGraph()`
`static Graph<Integer,DefaultEdge>`	`blanusaSecondSnarkGraph()`
`static Graph<Integer,DefaultEdge>`	`brinkmannGraph()`
`static Graph<Integer,DefaultEdge>`	`buckyBallGraph()`
`static Graph<Integer,DefaultEdge>`	`bullGraph()`
`static Graph<Integer,DefaultEdge>`	`butterflyGraph()`
`static Graph<Integer,DefaultEdge>`	`chvatalGraph()`
`static Graph<Integer,DefaultEdge>`	`clawGraph()`
`static Graph<Integer,DefaultEdge>`	`clebschGraph()`
`static Graph<Integer,DefaultEdge>`	`coxeterGraph()`
`static Graph<Integer,DefaultEdge>`	`desarguesGraph()`
`static Graph<Integer,DefaultEdge>`	`diamondGraph()`
`static Graph<Integer,DefaultEdge>`	`dodecahedronGraph()`
`static Graph<Integer,DefaultEdge>`	`doubleStarSnarkGraph()`
`static Graph<Integer,DefaultEdge>`	`doyleGraph()` Generate the Doyle Graph
`static Graph<Integer,DefaultEdge>`	`dürerGraph()`
`static Graph<Integer,DefaultEdge>`	`ellinghamHorton54Graph()`
`static Graph<Integer,DefaultEdge>`	`ellinghamHorton78Graph()`
`static Graph<Integer,DefaultEdge>`	`erreraGraph()`
`static Graph<Integer,DefaultEdge>`	`folkmanGraph()`
`static Graph<Integer,DefaultEdge>`	`franklinGraph()`
`static Graph<Integer,DefaultEdge>`	`fruchtGraph()`
`static Graph<Integer,DefaultEdge>`	`generalizedPetersenGraph(int n, int k)`
`void`	`generateBidiakisCubeGraph(Graph<V,E> targetGraph)` Generates a Bidiakis cube Graph.
`void`	`generateBlanusaFirstSnarkGraph(Graph<V,E> targetGraph)` Generates the First Blanusa Snark Graph.
`void`	`generateBlanusaSecondSnarkGraph(Graph<V,E> targetGraph)` Generates the Second Blanusa Snark Graph.
`void`	`generateBrinkmannGraph(Graph<V,E> targetGraph)` Generates the Brinkmann Graph.
`void`	`generateBuckyBallGraph(Graph<V,E> targetGraph)` Generates a Bucky ball Graph.
`void`	`generateBullGraph(Graph<V,E> targetGraph)` Generates a Bull Graph.
`void`	`generateButterflyGraph(Graph<V,E> targetGraph)` Generates a Butterfly Graph.
`void`	`generateChvatalGraph(Graph<V,E> targetGraph)` Generates the Chvatal Graph.
`void`	`generateClawGraph(Graph<V,E> targetGraph)` Generates a Claw Graph.
`void`	`generateClebschGraph(Graph<V,E> targetGraph)` Generates a Clebsch Graph.
`void`	`generateCoxeterGraph(Graph<V,E> targetGraph)` Generates the Coxeter Graph.
`void`	`generateDesarguesGraph(Graph<V,E> targetGraph)` Generates a Desargues Graph.
`void`	`generateDiamondGraph(Graph<V,E> targetGraph)` Generates the Diamond Graph.
`void`	`generateDodecahedronGraph(Graph<V,E> targetGraph)` Generates a Dodecahedron Graph.
`void`	`generateDoubleStarSnarkGraph(Graph<V,E> targetGraph)` Generates the Double Star Snark Graph.
`void`	`generateDoyleGraph(Graph<V,E> targetGraph)` Generates a Doyle Graph.
`void`	`generateDürerGraph(Graph<V,E> targetGraph)` Generates a Dürer Graph.
`void`	`generateEllinghamHorton54Graph(Graph<V,E> targetGraph)` Generates the Ellingham-Horton 54 Graph.
`void`	`generateEllinghamHorton78Graph(Graph<V,E> targetGraph)` Generates the Ellingham-Horton 78 Graph.
`void`	`generateErreraGraph(Graph<V,E> targetGraph)` Generates the Errera Graph.
`void`	`generateFolkmanGraph(Graph<V,E> targetGraph)` Generates the Folkman Graph.
`void`	`generateFranklinGraph(Graph<V,E> targetGraph)` Generates the Franklin Graph.
`void`	`generateFruchtGraph(Graph<V,E> targetGraph)` Generates the Frucht Graph.
`void`	`generateGoldnerHararyGraph(Graph<V,E> targetGraph)` Generates the Goldner-Harary Graph.
`void`	`generateGossetGraph(Graph<V,E> targetGraph)` Generates the Gosset Graph.
`void`	`generateGrötzschGraph(Graph<V,E> targetGraph)` Generates a Grötzsch Graph.
`void`	`generateHeawoodGraph(Graph<V,E> targetGraph)` Generates the Heawood Graph.
`void`	`generateHerschelGraph(Graph<V,E> targetGraph)` Generates the Herschel Graph.
`void`	`generateHoffmanGraph(Graph<V,E> targetGraph)` Generates the Hoffman Graph.
`void`	`generateKittellGraph(Graph<V,E> targetGraph)` Generates the Kittell Graph.
`void`	`generateKlein3RegularGraph(Graph<V,E> targetGraph)` Generates the Klein 3-regular Graph.
`void`	`generateKlein7RegularGraph(Graph<V,E> targetGraph)` Generates the Klein 7-regular Graph.
`void`	`generateKrackhardtKiteGraph(Graph<V,E> targetGraph)` Generates the Krackhardt kite Graph.
`void`	`generateMöbiusKantorGraph(Graph<V,E> targetGraph)` Generates a Möbius-Kantor Graph.
`void`	`generateMoserSpindleGraph(Graph<V,E> targetGraph)` Generates the Moser spindle Graph.
`void`	`generateNauruGraph(Graph<V,E> targetGraph)` Generates a Nauru Graph.
`void`	`generatePappusGraph(Graph<V,E> targetGraph)` Generates the Pappus Graph.
`void`	`generatePetersenGraph(Graph<V,E> targetGraph)` Generates a Petersen Graph.
`void`	`generatePoussinGraph(Graph<V,E> targetGraph)` Generates the Poussin Graph.
`void`	`generateSchläfliGraph(Graph<V,E> targetGraph)` Generates the Schläfli Graph.
`void`	`generateThomsenGraph(Graph<V,E> targetGraph)` Generates the Thomsen Graph.
`void`	`generateTietzeGraph(Graph<V,E> targetGraph)` Generates the Tietze Graph.
`void`	`generateTutteGraph(Graph<V,E> targetGraph)` Generates the Tutte Graph.
`static Graph<Integer,DefaultEdge>`	`goldnerHararyGraph()`
`static Graph<Integer,DefaultEdge>`	`gossetGraph()`
`static Graph<Integer,DefaultEdge>`	`grötzschGraph()`
`static Graph<Integer,DefaultEdge>`	`heawoodGraph()`
`static Graph<Integer,DefaultEdge>`	`herschelGraph()`
`static Graph<Integer,DefaultEdge>`	`hoffmanGraph()`
`static Graph<Integer,DefaultEdge>`	`kittellGraph()`
`static Graph<Integer,DefaultEdge>`	`klein3RegularGraph()`
`static Graph<Integer,DefaultEdge>`	`klein7RegularGraph()`
`static Graph<Integer,DefaultEdge>`	`krackhardtKiteGraph()`
`static Graph<Integer,DefaultEdge>`	`möbiusKantorGraph()`
`static Graph<Integer,DefaultEdge>`	`moserSpindleGraph()`
`static Graph<Integer,DefaultEdge>`	`nauruGraph()`
`static Graph<Integer,DefaultEdge>`	`pappusGraph()`
`static Graph<Integer,DefaultEdge>`	`petersenGraph()`
`static Graph<Integer,DefaultEdge>`	`poussinGraph()`
`static Graph<Integer,DefaultEdge>`	`schläfliGraph()`
`static Graph<Integer,DefaultEdge>`	`thomsenGraph()`
`static Graph<Integer,DefaultEdge>`	`tietzeGraph()`
`static Graph<Integer,DefaultEdge>`	`tutteGraph()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - NamedGraphGenerator
```
public NamedGraphGenerator()
```
    Constructs a new generator for named graphs
- Method Detail
  - doyleGraph
```
public static Graph<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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

Class NamedGraphGenerator<V,E>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

NamedGraphGenerator

Method Detail

doyleGraph

generateDoyleGraph

generalizedPetersenGraph

petersenGraph

generatePetersenGraph

dürerGraph

generateDürerGraph

dodecahedronGraph

generateDodecahedronGraph

desarguesGraph

generateDesarguesGraph

nauruGraph

generateNauruGraph

möbiusKantorGraph

generateMöbiusKantorGraph

bullGraph

generateBullGraph

butterflyGraph

generateButterflyGraph

clawGraph

generateClawGraph

buckyBallGraph

generateBuckyBallGraph

clebschGraph

generateClebschGraph

grötzschGraph

generateGrötzschGraph

bidiakisCubeGraph

generateBidiakisCubeGraph

blanusaFirstSnarkGraph

generateBlanusaFirstSnarkGraph

blanusaSecondSnarkGraph

generateBlanusaSecondSnarkGraph

doubleStarSnarkGraph

generateDoubleStarSnarkGraph

brinkmannGraph

generateBrinkmannGraph

gossetGraph

generateGossetGraph

chvatalGraph

generateChvatalGraph

kittellGraph

generateKittellGraph

coxeterGraph

generateCoxeterGraph

diamondGraph

generateDiamondGraph

ellinghamHorton54Graph

generateEllinghamHorton54Graph

ellinghamHorton78Graph

generateEllinghamHorton78Graph

erreraGraph

generateErreraGraph

folkmanGraph

generateFolkmanGraph

franklinGraph

generateFranklinGraph

fruchtGraph

generateFruchtGraph

goldnerHararyGraph

generateGoldnerHararyGraph

heawoodGraph

generateHeawoodGraph

herschelGraph

generateHerschelGraph

hoffmanGraph

generateHoffmanGraph

krackhardtKiteGraph

generateKrackhardtKiteGraph

klein3RegularGraph

generateKlein3RegularGraph

klein7RegularGraph

generateKlein7RegularGraph