@spec barbell(integer(), integer()) :: Yog.graph()

Generates the barbell graph B(m1, m2).

The barbell graph consists of two complete graphs K_{m1} connected by a path of m2 nodes. If m2 = 0, the two cliques are joined by a single edge.

Examples

iex> bar = Yog.Generator.Classic.barbell(4, 2)
iex> Yog.Model.order(bar)
10
iex> Yog.Model.edge_count(bar)
15

Properties

• Vertices: 2*m1 + m2
• Edges: m1*(m1-1) + m2 + 1
• Diameter: m2 + 2 (for m2 > 0)

References

• Wikipedia: Barbell Graph

@spec barbell_with_type(integer(), integer(), Yog.graph_type()) :: Yog.graph()

Generates the barbell graph with specified graph type.

@spec binary_tree(integer()) :: Yog.graph()

Generates a binary tree of specified depth.

A complete binary tree where each node (except leaves) has exactly 2 children. Total nodes: 2^(depth+1) - 1

Time Complexity: O(2^depth)

Examples

iex> tree = Yog.Generator.Classic.binary_tree(3)
iex> # Depth-3 binary tree: 1 + 2 + 4 + 8 = 15 nodes
...> Yog.Model.order(tree)
15

Use Cases

• Hierarchical structures
• Decision trees
• Search tree benchmarks

@spec binary_tree_with_type(integer(), Yog.graph_type()) :: Yog.graph()

Generates a binary tree with specified graph type.

@spec book(integer()) :: Yog.graph()

Generates the book graph B_n.

The book graph consists of n triangles (4-cycles in the general definition, but commonly triangles) all sharing a common edge (the "spine").

Examples

iex> book = Yog.Generator.Classic.book(3)
iex> Yog.Model.order(book)
5
iex> Yog.Model.edge_count(book)
7

Properties

• Vertices: n + 2 (2 spine vertices + n page vertices)
• Edges: 2n + 1 (n triangles sharing the spine edge)
• Planar
• Outerplanar

Use Cases

• Graph drawing and book embeddings
• Outerplanar graph studies
• Pagenumber of graphs

@spec book_with_type(integer(), Yog.graph_type()) :: Yog.graph()

Generates the book graph with specified graph type.

@spec caterpillar(
  integer(),
  keyword()
) :: Yog.graph()

Generates a caterpillar tree.

A caterpillar is a tree where removing all leaves leaves a path (the "spine").

Options

• :spine_length - Length of central path (default: max(1, div(n, 3)))
• :type - Graph type (:undirected or :directed, default: :undirected)

Examples

iex> cat = Yog.Generator.Classic.caterpillar(20, spine_length: 5)
iex> Yog.Model.order(cat)
20

Properties

• All vertices are within distance 1 of the central path
• Useful for testing algorithms sensitive to tree structure
• Interpolates between paths (spine_length = n) and stars (spine_length = 1)

Use Cases

• Testing tree isomorphism algorithms
• Algorithms with different behavior on paths vs stars
• Graph drawing and layout algorithms

@spec caterpillar_with_type(integer(), integer(), Yog.graph_type()) :: Yog.graph()

Generates a caterpillar tree with specified graph type.

@spec circular_ladder(integer()) :: Yog.graph()

Generates a circular ladder graph (prism graph) with n rungs.

The circular ladder CL_n consists of two concentric n-cycles with corresponding vertices connected by rungs. It's equivalent to the Cartesian product C_n × K_2 (cycle × edge).

Examples

iex> cl = Yog.Generator.Classic.circular_ladder(5)
iex> Yog.Model.order(cl)
10

iex> # CL_4 is the cube graph (isomorphic to hypercube(3))
...> cl4 = Yog.Generator.Classic.circular_ladder(4)
...> Yog.Model.order(cl4)
8

Properties

• Vertices: 2n
• Edges: 3n (2n cycle edges + n rungs)
• 3-regular (cubic) for n > 2
• Planar (can be drawn on a cylinder)
• Hamiltonian
• Bipartite when n is even

Use Cases

• Prism graphs in chemistry (molecular structures)
• Network topologies with wraparound
• Topological graph theory (cylindrical embeddings)

@spec circular_ladder_with_type(integer(), Yog.graph_type()) :: Yog.graph()

Generates a circular ladder graph with specified graph type.

@spec complete(integer()) :: Yog.graph()

Generates a complete graph K_n where every node connects to every other.

In a complete graph with n nodes, there are n(n-1)/2 edges for undirected graphs and n(n-1) edges for directed graphs. All edges have unit weight (1).

Time Complexity: O(n²)

Examples

iex> k5 = Yog.Generator.Classic.complete(5)
iex> Yog.Model.order(k5)
5
iex> # K5 is undirected, each node has 4 neighbors
...> length(Yog.neighbors(k5, 0))
4

Use Cases

• Testing algorithms on dense graphs
• Maximum connectivity scenarios
• Clique detection benchmarks

@spec complete_bipartite(integer(), integer()) :: Yog.graph()

Generates a complete bipartite graph K_{m,n}.

In a complete bipartite graph, every node in the first partition connects to every node in the second partition.

Time Complexity: O(mn)

Examples

iex> k34 = Yog.Generator.Classic.complete_bipartite(3, 4)
iex> Yog.Model.order(k34)
7
iex> # First partition nodes (0-2) have degree 4
...> length(Yog.neighbors(k34, 0))
4
iex> # Second partition nodes (3-6) have degree 3
...> length(Yog.neighbors(k34, 3))
3

Use Cases

• Bipartite matching problems
• Assignment problems
• Recommender systems

@spec complete_bipartite_with_type(integer(), integer(), Yog.graph_type()) ::
  Yog.graph()

Generates a complete bipartite graph with specified graph type.

@spec complete_kary(
  integer(),
  keyword()
) :: Yog.graph()

Generates a complete m-ary tree with exactly n nodes.

Creates a tree that is as complete as possible - all levels are fully filled except possibly the last, which is filled from left to right.

Options

• :arity - Branching factor (default: 2)
• :type - Graph type (:undirected or :directed, default: :undirected)

Examples

iex> tree = Yog.Generator.Classic.complete_kary(20, arity: 3)
iex> Yog.Model.order(tree)
20

iex> tree = Yog.Generator.Classic.complete_kary(7, arity: 2)
iex> Yog.Model.edge_count(tree)
6

Use Cases

• Complete binary trees for heap implementations
• Testing tree algorithms with specific node counts
• B-tree node structure validation

@spec complete_kary_with_type(integer(), pos_integer(), Yog.graph_type()) ::
  Yog.graph()

Generates a complete m-ary tree with specified graph type.

@spec complete_with_type(integer(), Yog.graph_type()) :: Yog.graph()

Generates a complete graph with specified graph type.

Examples

iex> directed_k4 = Yog.Generator.Classic.complete_with_type(4, :directed)
iex> Yog.Model.type(directed_k4)
:directed
iex> Yog.Model.order(directed_k4)
4

@spec crown(integer()) :: Yog.graph()

Generates the crown graph S_n^0 with 2n vertices.

The crown graph is the complete bipartite graph K_{n,n} minus a perfect matching. It has important applications in edge coloring and extremal graph theory.

Examples

iex> crown = Yog.Generator.Classic.crown(4)
iex> Yog.Model.order(crown)
8
iex> Yog.Model.edge_count(crown)
12

iex> # crown(2) is C_4 (cycle on 4 vertices)
...> c2 = Yog.Generator.Classic.crown(2)
...> Yog.Model.order(c2)
4

Properties

• Vertices: 2n
• Edges: n(n-1) = n² - n
• (n-1)-regular (each vertex has degree n-1)
• Bipartite
• Diameter: 3 for n ≥ 3
• Girth: 4 for n ≥ 3

Special Cases

• crown(2) = C₄ (4-cycle)
• crown(3) is the utility graph (K_{3,3} minus a perfect matching)

Use Cases

• Edge coloring tests (chromatic index demonstrations)
• Extremal graph theory examples
• Bipartite graph testing with symmetric structure

@spec crown_with_type(integer(), Yog.graph_type()) :: Yog.graph()

Generates the crown graph with specified graph type.

@spec cube() :: Yog.graph()

Generates the cube graph Q₃ (3-dimensional hypercube).

The cube has 8 vertices and 12 edges. Each vertex has degree 3. It is bipartite, planar, and is the 3D hypercube.

Examples

iex> cube = Yog.Generator.Classic.cube()
iex> Yog.Model.order(cube)
8
iex> Yog.Model.edge_count(cube)
12

Properties

• Vertices: 8
• Edges: 12
• Degree: 3 (regular)
• Diameter: 3
• Girth: 4
• Chromatic number: 2 (bipartite)

@spec cycle(integer()) :: Yog.graph()

Generates a cycle graph C_n where nodes form a ring.

A cycle graph connects n nodes in a circular pattern: 0 -> 1 -> 2 -> ... -> (n-1) -> 0. Each node has degree 2.

Returns an empty graph if n < 3 (cycles require at least 3 nodes).

Time Complexity: O(n)

Examples

iex> c6 = Yog.Generator.Classic.cycle(6)
iex> Yog.Model.order(c6)
6
iex> # Each node in a cycle has degree 2
...> length(Yog.neighbors(c6, 0))
2

Use Cases

• Ring network topologies
• Circular dependency testing
• Hamiltonian cycle benchmarks

@spec cycle_with_type(integer(), Yog.graph_type()) :: Yog.graph()

Generates a cycle graph with specified graph type.

@spec dodecahedron() :: Yog.graph()

Generates the dodecahedron graph.

The dodecahedron has 20 vertices and 30 edges. Each vertex has degree 3. Famous as the basis of Hamilton's "Icosian game" and Hamiltonian cycle puzzles. It has girth 5 (smallest cycle has 5 edges).

Examples

iex> dodec = Yog.Generator.Classic.dodecahedron()
iex> Yog.Model.order(dodec)
20
iex> Yog.Model.edge_count(dodec)
30

Properties

• Vertices: 20
• Edges: 30
• Degree: 3 (regular)
• Diameter: 5
• Girth: 5
• Chromatic number: 3

@spec empty(integer()) :: Yog.graph()

Generates an empty graph with n isolated nodes (no edges).

Time Complexity: O(n)

Examples

iex> empty5 = Yog.Generator.Classic.empty(5)
iex> Yog.Model.order(empty5)
5
iex> # No edges - isolated nodes have degree 0
...> length(Yog.neighbors(empty5, 0))
0

@spec empty_with_type(integer(), Yog.graph_type()) :: Yog.graph()

Generates an empty graph with specified graph type.

@spec friendship(integer()) :: Yog.graph()

Generates the friendship graph F_n with n triangles.

The friendship graph consists of n triangles all sharing a common vertex. Also known as the Dutch windmill graph W_n^{(3)} or the friendship theorem graph.

Famous for the Friendship Theorem: if every pair of vertices in a finite graph has exactly one common neighbor, then the graph must be a friendship graph.

Examples

iex> f3 = Yog.Generator.Classic.friendship(3)
iex> Yog.Model.order(f3)
7
iex> Yog.Model.edge_count(f3)
9

Properties

• Vertices: 2n + 1 (1 center + 2n outer vertices)
• Edges: 3n (n triangles, each with 3 edges)
• Center has degree 2n, outer vertices have degree 2
• Chromatic number: 3
• Diameter: 2, Radius: 1
• Planar

Use Cases

• Graph theory education (Friendship Theorem)
• Testing graphs with specific local properties
• Social network models (hub with triadic closure)

@spec friendship_with_type(integer(), Yog.graph_type()) :: Yog.graph()

Generates the friendship graph with specified graph type.

@spec grid_2d(integer(), integer()) :: Yog.graph()

Generates a 2D grid (lattice) graph with specified rows and columns.

Each cell connects to its adjacent neighbors (up, down, left, right).

Time Complexity: O(rows × cols)

Examples

iex> grid = Yog.Generator.Classic.grid_2d(3, 4)
iex> # 3x4 grid has 12 nodes
...> Yog.Model.order(grid)
12
iex> # Corner nodes have degree 2
...> length(Yog.neighbors(grid, 0))
2
iex> # Interior nodes have degree 4
...> length(Yog.neighbors(grid, 5))
4

Use Cases

• Mesh networks
• Image processing
• Spatial simulations

@spec grid_2d_with_type(integer(), integer(), Yog.graph_type()) :: Yog.graph()

Generates a 2D grid with specified graph type.

@spec hypercube(integer()) :: Yog.graph()

Generates an n-dimensional hypercube graph Q_n.

The hypercube is a classic topology where each node represents a binary string of length n, and edges connect nodes that differ in exactly one bit.

Properties:

• Nodes: 2^n
• Edges: n × 2^(n-1)
• Regular degree: n
• Diameter: n
• Bipartite: yes

Time Complexity: O(n × 2^n)

Examples

iex> cube = Yog.Generator.Classic.hypercube(3)
iex> # 3-cube has 8 nodes
...> Yog.Model.order(cube)
8
iex> # Each node has degree 3
...> length(Yog.neighbors(cube, 0))
3
iex> # 3-cube has 12 edges
...> Yog.Model.edge_count(cube)
12

Use Cases

• Distributed systems and parallel computing topologies
• Error-correcting codes
• Testing algorithms on regular, bipartite structures
• Gray code applications

References

• Wikipedia: Hypercube Graph

@spec hypercube_with_type(integer(), Yog.graph_type()) :: Yog.graph()

Generates a hypercube graph with specified graph type.

@spec icosahedron() :: Yog.graph()

Generates the icosahedron graph.

The icosahedron has 12 vertices and 30 edges. Each vertex has degree 5. It is the dual of the dodecahedron. It has the largest number of faces (20) of any Platonic solid.

Examples

iex> icosa = Yog.Generator.Classic.icosahedron()
iex> Yog.Model.order(icosa)
12
iex> Yog.Model.edge_count(icosa)
30

Properties

• Vertices: 12
• Edges: 30
• Degree: 5 (regular)
• Diameter: 3
• Girth: 3
• Chromatic number: 4

@spec kary_tree(
  non_neg_integer(),
  keyword()
) :: Yog.graph()

Generates a complete k-ary tree of given depth.

A complete k-ary tree where each node has exactly k children (except leaves). Total nodes = (k^(depth+1) - 1) / (k - 1) for k > 1. For k = 1, this is a path with depth+1 nodes.

Options

• :arity - Branching factor k (default: 2, binary tree)
• :type - Graph type (:undirected or :directed, default: :undirected)

Examples

iex> # Ternary tree (arity 3) of depth 2
...> tree = Yog.Generator.Classic.kary_tree(2, arity: 3)
iex> Yog.Model.order(tree)
13

iex> # Star is kary_tree with depth 1
...> star = Yog.Generator.Classic.kary_tree(1, arity: 5)
iex> Yog.Model.order(star)
6

Properties

• Regular tree structure useful for k-ary heaps
• Node i has parent at floor((i-1)/k)
• Node i has children at ki+1 through ki+k

Use Cases

• k-ary heap implementations
• Trie structures
• B-tree testing

@spec kary_tree_with_type(non_neg_integer(), pos_integer(), Yog.graph_type()) ::
  Yog.graph()

Generates a k-ary tree with specified graph type.

@spec ladder(integer()) :: Yog.graph()

Generates a ladder graph with n rungs.

A ladder graph consists of two parallel paths (rails) connected by n rungs. It is the Cartesian product of a path P_n and an edge K_2.

Properties:

• Nodes: 2n
• Edges: 3n - 2
• Planar: yes
• Equivalent to grid_2d(2, n)

Time Complexity: O(n)

Examples

iex> ladder = Yog.Generator.Classic.ladder(4)
iex> # 4-rung ladder has 8 nodes
...> Yog.Model.order(ladder)
8
iex> # End nodes have degree 2
...> length(Yog.neighbors(ladder, 0))
2
iex> # Interior nodes have degree 3
...> length(Yog.neighbors(ladder, 2))
3

Use Cases

• Basic network topologies
• DNA and molecular structure modeling
• Pathfinding benchmarks

@spec ladder_with_type(integer(), Yog.graph_type()) :: Yog.graph()

Generates a ladder graph with specified graph type.

@spec lollipop(integer(), integer()) :: Yog.graph()

Generates the lollipop graph L(m, n).

The lollipop graph consists of a complete graph K_m connected to a path P_n by a single bridge edge. This is an extremal example in the study of random walks on graphs.

Examples

iex> lol = Yog.Generator.Classic.lollipop(4, 3)
iex> Yog.Model.order(lol)
7
iex> Yog.Model.edge_count(lol)
9

Properties

• Vertices: m + n
• Edges: m(m-1)/2 + n
• Diameter: n + 1 (for m > 1 and n > 0)

References

• Wikipedia: Lollipop Graph

@spec lollipop_with_type(integer(), integer(), Yog.graph_type()) :: Yog.graph()

Generates the lollipop graph with specified graph type.

@spec mobius_ladder(integer()) :: Yog.graph()

Generates a Möbius ladder graph with n rungs.

The Möbius ladder ML_n is formed from a circular ladder by giving it a half-twist before connecting the ends, creating a Möbius strip topology.

Examples

iex> ml = Yog.Generator.Classic.mobius_ladder(6)
iex> Yog.Model.order(ml)
12

iex> # ML_4 is K_{3,3} (complete bipartite graph)
...> ml4 = Yog.Generator.Classic.mobius_ladder(4)
...> Yog.Model.order(ml4)
8

Properties

• Vertices: 2n
• Edges: 3n
• 3-regular (cubic)
• Non-planar for n ≥ 3
• ML4 = K{3,3} (canonical non-planar graph)
• ML3 = 6-vertex utility graph (K{3,3} minus an edge)
• Bipartite when n is odd

Use Cases

• Non-orientable embeddings in topological graph theory
• Planarity testing (contains K_{3,3} minor)
• Chemical graph theory (Möbius molecules)
• Network design with twisted topology

@spec mobius_ladder_with_type(integer(), Yog.graph_type()) :: Yog.graph()

Generates a Möbius ladder graph with specified graph type.

@spec octahedron() :: Yog.graph()

Generates the octahedron graph.

The octahedron has 6 vertices and 12 edges. Each vertex has degree 4. It is the dual of the cube. Vertices can be viewed as the coordinate axes (±1, 0, 0), (0, ±1, 0), (0, 0, ±1) - each vertex connects to all except its opposite.

Examples

iex> octa = Yog.Generator.Classic.octahedron()
iex> Yog.Model.order(octa)
6
iex> Yog.Model.edge_count(octa)
12

Properties

• Vertices: 6
• Edges: 12
• Degree: 4 (regular)
• Diameter: 2
• Girth: 3
• Chromatic number: 3

@spec path(integer()) :: Yog.graph()

Generates a path graph P_n where nodes form a linear chain.

A path graph connects n nodes in a line: 0 -> 1 -> 2 -> ... -> (n-1). End nodes have degree 1, interior nodes have degree 2.

Time Complexity: O(n)

Examples

iex> p5 = Yog.Generator.Classic.path(5)
iex> Yog.Model.order(p5)
5
iex> # End nodes have degree 1
...> length(Yog.neighbors(p5, 0))
1
iex> # Middle nodes have degree 2
...> length(Yog.neighbors(p5, 2))
2

Use Cases

• Linear network topologies
• Linked list representations
• Pathfinding benchmarks

@spec path_with_type(integer(), Yog.graph_type()) :: Yog.graph()

Generates a path graph with specified graph type.

@spec petersen() :: Yog.graph()

Generates the Petersen graph - a famous graph in graph theory.

The Petersen graph has 10 nodes, 15 edges, diameter 2, girth 5. It's a common counterexample in graph theory.

Time Complexity: O(1)

Examples

iex> p = Yog.Generator.Classic.petersen()
iex> # Petersen graph has 10 nodes
...> Yog.Model.order(p)
10
iex> # All nodes have degree 3
...> length(Yog.neighbors(p, 0))
3

Properties

• Non-planar
• Non-Hamiltonian
• Vertex-transitive
• Chromatic number 3

@spec petersen_with_type(Yog.graph_type()) :: Yog.graph()

Generates the Petersen graph with specified graph type.

@spec prism(integer()) :: Yog.graph()

Alias for circular_ladder/1.

The n-sided prism graph is exactly the circular ladder CL_n.

@spec sedgewick_maze() :: Yog.graph()

Generates the Sedgewick maze graph.

A small maze with a cycle used in Sedgewick's Algorithms, 3rd Edition, Part 5, Graph Algorithms, Chapter 18 (Figure 18.2). It has 8 nodes and 10 edges.

Examples

iex> maze = Yog.Generator.Classic.sedgewick_maze()
iex> Yog.Model.order(maze)
8
iex> Yog.Model.edge_count(maze)
10

References

• Figure 18.2, Chapter 18, Graph Algorithms (3rd Ed), Sedgewick

@spec sedgewick_maze_with_type(Yog.graph_type()) :: Yog.graph()

Generates the Sedgewick maze graph with specified graph type.

@spec star(integer()) :: Yog.graph()

Generates a star graph S_n with one central hub.

A star graph has one central node (0) connected to all n-1 outer nodes. The center has degree n-1, outer nodes have degree 1.

Time Complexity: O(n)

Examples

iex> s5 = Yog.Generator.Classic.star(5)
iex> Yog.Model.order(s5)
5
iex> # Center (node 0) has degree 4
...> length(Yog.neighbors(s5, 0))
4
iex> # Leaf nodes have degree 1
...> length(Yog.neighbors(s5, 1))
1

Use Cases

• Hub-and-spoke networks
• Client-server architectures
• Broadcast scenarios

@spec star_with_type(integer(), Yog.graph_type()) :: Yog.graph()

Generates a star graph with specified graph type.

@spec tetrahedron() :: Yog.graph()

Generates the tetrahedron graph K₄ (complete graph on 4 vertices).

The tetrahedron is the simplest Platonic solid with 4 vertices and 6 edges. Each vertex has degree 3. It is a complete graph K₄.

Examples

iex> tetra = Yog.Generator.Classic.tetrahedron()
iex> Yog.Model.order(tetra)
4
iex> Yog.Model.edge_count(tetra)
6

Properties

• Vertices: 4
• Edges: 6
• Degree: 3 (regular)
• Diameter: 1
• Girth: 3
• Chromatic number: 4

@spec turan(integer(), integer()) :: Yog.graph()

Generates the Turán graph T(n, r).

The Turán graph is a complete r-partite graph with n vertices where partitions are as equal as possible. It maximizes the number of edges among all n-vertex graphs that do not contain K_{r+1} as a subgraph.

Properties:

• Complete r-partite with balanced partitions
• Maximum edge count without containing K_{r+1}
• Chromatic number: r (for n >= r)
• Turán's theorem: extremal graph for forbidden cliques

Time Complexity: O(n²)

Examples

iex> turan = Yog.Generator.Classic.turan(10, 3)
iex> # T(10, 3) has 10 nodes
...> Yog.Model.order(turan)
10
iex> # Partition sizes are balanced: 4, 3, 3
iex> # No edges within partitions, all edges between

iex> # T(n, 2) is the complete bipartite graph
...> k33 = Yog.Generator.Classic.turan(6, 2)
...> Yog.Model.order(k33)
6

Use Cases

• Extremal graph theory testing
• Chromatic number benchmarks
• Anti-clique (independence number) studies
• Balanced multi-partite networks

References

• Wikipedia: Turán Graph
• Turán's Theorem

@spec turan_with_type(integer(), integer(), Yog.graph_type()) :: Yog.graph()

Generates a Turán graph with specified graph type.

@spec tutte() :: Yog.graph()

Generates the Tutte graph.

The Tutte graph is a 3-regular (cubic) polyhedral graph with 46 vertices and 69 edges. It is non-Hamiltonian and serves as a counterexample to Tait's conjecture that every 3-regular polyhedron has a Hamiltonian cycle.

Examples

iex> tutte = Yog.Generator.Classic.tutte()
iex> Yog.Model.order(tutte)
46
iex> Yog.Model.edge_count(tutte)
69

Properties

• Vertices: 46
• Edges: 69
• Degree: 3 (cubic)
• Non-Hamiltonian
• Planar

References

• Wikipedia: Tutte Graph

@spec tutte_with_type(Yog.graph_type()) :: Yog.graph()

Generates the Tutte graph with specified graph type.

@spec wheel(integer()) :: Yog.graph()

Generates a wheel graph W_n - a cycle with a central hub.

A wheel graph combines a star and a cycle: center (0) connects to all rim nodes (1..n-1), and rim nodes form a cycle.

Time Complexity: O(n)

Examples

iex> w6 = Yog.Generator.Classic.wheel(6)
iex> Yog.Model.order(w6)
6
iex> # Center has degree 5 (connected to all rim nodes)
...> length(Yog.neighbors(w6, 0))
5
iex> # Rim nodes have degree 3 (center + 2 neighbors in cycle)
...> length(Yog.neighbors(w6, 1))
3

Use Cases

• Wheel network topologies
• Centralized routing with backup paths
• Spoke-hub distribution

@spec wheel_with_type(integer(), Yog.graph_type()) :: Yog.graph()

Generates a wheel graph with specified graph type.

@spec windmill(
  integer(),
  keyword()
) :: Yog.graph()

Generates the windmill graph W_n^{(k)}.

Generalization of the friendship graph where n copies of K_k (complete graph on k vertices) share a common vertex. The friendship graph is W_n^{(3)}.

Options

• :clique_size - Size k of the cliques (default: 3)

Examples

iex> # Windmill of 4 triangles (same as friendship(4))
...> w4 = Yog.Generator.Classic.windmill(4, clique_size: 3)
iex> Yog.Model.order(w4)
9

iex> # Windmill of 3 squares (4-cliques sharing a vertex)
...> w3_4 = Yog.Generator.Classic.windmill(3, clique_size: 4)
iex> Yog.Model.order(w3_4)
10

Properties

• Vertices: 1 + n(k-1)
• Edges: n × C(k,2) = n × k(k-1)/2
• Center has degree n(k-1)

Use Cases

• Generalized friendship graphs
• Intersection graph theory
• Clique decomposition studies

@spec windmill_with_type(integer(), integer(), Yog.graph_type()) :: Yog.graph()

Generates the windmill graph with specified graph type.