diff --git a/doc/examples.xml b/doc/examples.xml
index 28dd597c0..d3c63f92f 100644
--- a/doc/examples.xml
+++ b/doc/examples.xml
@@ -856,3 +856,751 @@ gap> BinaryTree(IsMutableDigraph, 8);
   </Description>
 </ManSection>
 <#/GAPDoc>
+
+<#GAPDoc Label="AndrasfaiGraph">
+<ManSection>
+  <Oper Name="AndrasfaiGraph" Arg="[filt, ]n"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is an integer greater than 0, then this operation returns the
+    <A>n</A>th <E>Andrasfai graph</E>. The Andrasfai graph is a circulant graph
+    with <C>3<A>n</A> - 1</C> vertices. The indices of the Andrasfai graph
+    are given by the numbers between <C>1</C> and <C>3<A>n</A> - 1</C> that are
+    congruent to <C>1</C> mod <C>3</C> (that is, for each index <M>j</M>, vertex
+    <M>i</M> is adjacent to the <M>i + j</M>th and <M>i - j</M> vertices). The
+    graph has <C>6(3<A>n</A> - 1)</C> edges. The graph is triangle free.<P/>
+
+    As a circulant graph, the Andrasfai graph is biconnected, cyclic,
+    Hamiltonian, regular, and vertex transitive.<P/>
+
+    See <URL>https://mathworld.wolfram.com/AndrasfaiGraph.html</URL> for further
+    details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := AndrasfaiGraph(4);
+<immutable Hamiltonian biconnected vertex-transitive symmetric digraph\
+ with 11 vertices, 44 edges>
+gap> IsBiconnectedDigraph(D);
+true
+gap> IsIsomorphicDigraph(D, CirculantGraph(11, [1, 4, 7, 10]));
+true]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="BinomialTreeGraph">
+<ManSection>
+  <Oper Name="BinomialTreeGraph" Arg="[filt, ]n"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is a positive integer then this operation returns the <A>n</A>th
+    <E>binomial tree graph</E>. The binomial tree graph has <A>n</A> vertices
+    and <C><A>n</A>-1</C> undirected edges. The vertices of the binomial tree
+    graph are the numbers from 1 to <A>n</A> in binary representation, with a
+    vertex <C>v</C> having as a direct parent the vertex with binary
+    representation the same as <C>v</C> but with the lowest 1-bit cleared. For
+    example, the vertex <M>011</M> has parent <M>010</M>, and the vertex
+    <M>010</M> has parent <M>000</M>.<P/>
+
+    The binomial tree graph is an undirected tree, and is symmetric as a
+    digraph.<P/>
+
+    See <URL>https://metacpan.org/pod/Graph::Maker::BinomialTree</URL> for
+    further details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := BinomialTreeGraph(9);
+<immutable undirected tree digraph with 9 vertices>]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="BondyGraph">
+<ManSection>
+  <Oper Name="BondyGraph" Arg="[filt, ]n"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is a non-negative integer then this operation returns the
+    <A>n</A>th <E>Bondy graph</E>. The Bondy graphs are a family of
+    hypohamiltonian graphs: a graph which is not Hamiltonian itself but the
+    removal of any vertex produces a Hamiltonian graph. The Bondy graphs are the
+    <C>(3(2<A>n</A> + 1) + 2, 2)</C>-th Generalised Petersen graphs, and have
+    <C>12<A>n</A> + 10</C> vertices and <C>15 + 18<A>n</A></C> undirected
+    edges.<P/>
+
+    See <URL>https://mathworld.wolfram.com/HypohamiltonianGraph.html</URL> for
+    further details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := BondyGraph(1);
+<immutable symmetric digraph with 22 vertices, 66 edges>
+gap> IsHamiltonianDigraph(D);
+false
+gap> G := List([1 .. 22], x -> DigraphRemoveVertex(D, x));;
+gap> ForAll(G, x -> IsHamiltonianDigraph(x));
+true]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="CirculantGraph">
+<ManSection>
+  <Oper Name="CirculantGraph" Arg="[filt, ]n, par"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is an integer greater than 1, and <A>par</A> is a list of
+    integers that are contained in <C>[1..<A>n</A>]</C> then this operation
+    returns a <E>circulant graph</E>. The circulant graph is a graph on <A>n</A>
+    vertices, where for each element <M>j</M> of <A>par</A>, the <M>i</M>th
+    vertex is adjacent to the <M>(i + j)</M>th and <M>(i - j)</M>th
+    vertices.<P/>
+
+    If <A>par</A> is <M>[1]</M>, then the graph is the <A>n</A>th cyclic graph.
+    If <A>par</A> is <C>[1,2,...,Int(<A>n</A>/2)]</C>, then the graph is the
+    complete graph on <A>n</A> vertices. If <A>n</A> is at least 4 and
+    <A>par</A> is <C>[1,<A>n</A>]</C> then the graph is the <A>n</A>th Mobius
+    ladder graph.<P/>
+
+    A circulant graph is biconnected, cyclic, Hamiltonian, regular, and vertex
+    transitive.<P/>
+
+    See <URL>https://mathworld.wolfram.com/CirculantGraph.html</URL> for further
+    details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := CirculantGraph(6, [1, 2, 3]);
+<immutable Hamiltonian biconnected vertex-transitive symmetric digraph\
+ with 6 vertices, 30 edges>
+gap> IsIsomorphicDigraph(D, CompleteDigraph(6));
+true]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="CycleGraph">
+<ManSection>
+  <Oper Name="CycleGraph" Arg="[filt, ]n"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is an integer greater than 2 then this operation returns the
+    <A>n</A>th <E>cycle graph</E>, consisting of the cycle on <A>n</A> vertices.
+    The cycle graph, unlike the cycle digraph, is symmetric. The cycle graph
+    has <A>n</A> vertices and <A>n</A> undirected edges. The cycle graph is
+    simple so the non-simple graphs with a single vertex and single loop and
+    with two vertices and two edges between them are excluded.<P/>
+
+    See <URL>https://mathworld.wolfram.com/CycleGraph.html</URL> for
+    further details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := CycleGraph(7);
+<immutable symmetric digraph with 7 vertices, 14 edges>]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="GearGraph">
+<ManSection>
+  <Oper Name="GearGraph" Arg="[filt, ]n"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is a positive integer at least 3, then this operation
+    returns the <E>gear graph</E> with <C>2<A>n</A> + 1</C> vertices and
+    <C>3<A>n</A></C> undirected edges. The <A>n</A>th gear graph is the
+    <C>2<A></A></C>th cycle graph with one additional central vertex, to which
+    every other vertex of the cycle is connected. The gear graph is a symmetric
+    digraph.  A gear graph is a Matchstick graph, that is it is simple with a
+    planar graph embedding, and is a unit-distance graph (that is, it can be
+    embedded into the Euclidean plane with vertices being distinct points and
+    edges having length 1).<P/>
+
+    See <URL>https://mathworld.wolfram.com/GearGraph.html</URL> for further
+    details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := GearGraph(4);
+<immutable symmetric digraph with 9 vertices, 24 edges>
+gap> ChromaticNumber(D);
+2
+gap> IsVertexTransitive(D);
+false]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="HalvedCubeGraph">
+<ManSection>
+  <Oper Name="HalvedCubeGraph" Arg="[filt, ]n"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is a positive integer at least 1, then this operation returns
+    the <A>n</A>th <E>halved cube graph</E>, the graph of the <A>n</A>-
+    demihypercube. The vertices of the graph are those of the <A>n</A>th-
+    hypercube, with two vertices adjacent if and only if they are at distance 1
+    or 2 from each other. Equivalent constructions are as the second graph power
+    of the <C><A>n</A>-1</C>th hypercube graph, or as with vertices labelled as
+    the binary numbers where two vertices are adjacent if they differ in a
+    single bit, or with vertices labelled with the subset of binary numbers with
+    even Hamming weight, with edges connecting vertices with Hamming distance
+    exactly 2. The Halved Cube graph is distance regular and contains a
+    Hamiltonian cycle.<P/>
+
+    See <URL>https://mathworld.wolfram.com/HalvedCubeGraph.html</URL> for
+    further details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := HalvedCubeGraph(3);
+<immutable Hamiltonian connected symmetric digraph with 4 vertices, 12\
+ edges>
+gap> IsDistanceRegularDigraph(D);
+true
+gap> IsHamiltonianDigraph(D);
+true]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="HanoiGraph">
+<ManSection>
+  <Oper Name="HanoiGraph" Arg="[filt, ]n"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is positive integer then this operation returns the <A>n</A>th
+    <E>Hanoi graph</E>. The Hanoi graph's vertices represent the possible states
+     of the 'Tower of Hanoi' puzzle on three 'towers', while its edges represent
+     possible moves. The Hanoi graph has <C>3^<A>n</A></C> vertices, and
+     <C>Binomial(3, 3) * (3^<A>n</A> - 1) / 2</C> undirected edges.<P/>
+
+    The Hanoi graph is Hamiltonian. The graph superficially resembles the
+    Sierpinski triangle. The graph is also a 'penny graph' - a graph whose
+    vertices can be considered to be non-overlapping unit circles on a flat
+    surface, with two vertices adjacent only if the unit circles touch at a
+    single point. Thus the Hanoi graph is planar.<P/>
+
+    See <URL>https://mathworld.wolfram.com/HanoiGraph.html</URL> for
+    further details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := HanoiGraph(5);
+<immutable Hamiltonian connected symmetric digraph with 243 vertices, \
+726 edges>
+gap> IsPlanarDigraph(D);
+true]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="HelmGraph">
+<ManSection>
+  <Oper Name="HelmGraph" Arg="[filt, ]n"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is a positive integer at least 3, then this operation returns
+    the <A>n</A>th <E>helm graph</E>. The helm graph is the <A>n</A>-1th wheel
+    graph with, for each external vertex of the 'wheel', adjoining a new vertex
+    incident only to the first vertex. That is, the graph looks similar to
+    a ship's helm.<P/>
+
+    See <URL>https://mathworld.wolfram.com/WheelGraph.html</URL> for further
+    details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := HelmGraph(4);
+<immutable symmetric digraph with 9 vertices, 24 edges>]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="HypercubeGraph">
+<ManSection>
+  <Oper Name="HypercubeGraph" Arg="[filt, ]n"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is a non-negative integer, then this operation returns the
+    <A>n</A>th <E>hypercube graph</E>. The graph has <C>2^<A>n</A></C> vertices
+    and <C>2^(<A>n</A>-1)<A>n</A></C> edges. It is formed from the vertices and
+    edges of the <A>n</A>-dimensional hypercube. Alternatively, the graph can be
+    constructed by labelling each vertex with the binary numbers, with two
+    vertices adjacent if they have Hamming distance exactly one. The hypercube
+    graphs are Hamiltonian, distance-transitive and therefore distance-regular,
+    and bipartite.<P/>
+
+    See <URL>https://mathworld.wolfram.com/HypercubeGraph.html</URL> for further
+    details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := HypercubeGraph(5);
+<immutable Hamiltonian connected bipartite symmetric digraph with bico\
+mponent sizes 16 and 16>
+]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="KellerGraph">
+<ManSection>
+  <Oper Name="KellerGraph" Arg="[filt, ]n"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is a nonnegative integer then this operation returns the
+    <A>n</A>th or <A>n</A>-dimensional <E>Keller graph</E>. The graph has
+    vertices given by the <A>n</A>-tuples on the set <M>[0, 1, 2, 3]</M>.
+    Two vertices are adjacent if their respective tuples are such that they
+    differ in at least two coordinates and in at least one coordinate the
+    difference between the two is <C>2</C> mod <C>4</C>. The Keller graph has
+    <C>4^<A>n</A></C> vertices.<P/>
+
+    The Keller graphs were constructed with the intention of finding
+    counterexamples to Keller's conjecture
+    (<URL>https://mathworld.wolfram.com/KellersConjecture.html</URL>), and has
+    been used since for testing maximum clique algorithms.<P/>
+
+    If <A>n</A> is 1 then the graph is empty, for <A>n</A> greater than 1 the
+    chromatic number of the Keller graph is <C>2^<A>n</A></C> and the graph is
+    Hamiltonian.<P/>
+
+    See <URL>https://mathworld.wolfram.com/KellerGraph.html</URL> for further
+    details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := KellerGraph(3);
+<immutable Hamiltonian connected symmetric digraph with 64 vertices, 2\
+176 edges>
+gap> ChromaticNumber(D);
+8]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="KneserGraph">
+<ManSection>
+  <Oper Name="KneserGraph" Arg="[filt, ]n, k"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> and <A>k</A> are integers greater than 0, with <A>k</A> less
+    than <A>n</A>, then this operation returns the <C>(<A>n</A>,<A>k</A>)</C>-th
+    <E>Kneser graph</E>. The Kneser graph's vertices correspond to the <A>k</A>-
+    element subsets of a set of <A>n</A> elements, with two vertices being
+    adjacent if and only if the subsets are disjoint. The graph has
+    <C>Binomial(<A>n</A>, <A>k</A>)</C> vertices and <C>Binomial(<A>n</A>,
+    <A>k</A>) * Binomial(<A>n</A> - <A>k</A>, <A>k</A>)</C> edges. Kneser graphs
+    are regular, edge transitive, and vertex transitive. If <A>k</A> is 1, then
+    the graph is the complete graph on <A>n</A> vertices. If <C>(<A>n</A>,
+    <A>k</A>)</C> is <C>(2m-1, <A>n</A>-1)</C>, then the graph is the <C>m</C>th
+    Odd graph. The Petersen graph is the <M>(5, 2)</M>th Kneser graph.<P/>
+
+    If <C><A>n</A> >= 2<A>k</A></C> then the graph's chromatic number is
+    <C><A>n</A> - 2<A>k</A> + 2</C>, and otherwise is 1. The Kneser graph
+    contains a Hamiltonian cycle if <C><A>n</A> >= ((3 + 5 ^ 0.5) / 2)<A>k</A> +
+    1</C>. The graph has clique number equal to the floor of <C><A>n</A> /
+    <A>k</A></C>.<P/>
+
+    See <URL>https://mathworld.wolfram.com/KneserGraph.html</URL> for further
+    details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := KneserGraph(7, 3);
+<immutable edge- and vertex-transitive symmetric digraph with 35 verti\
+ces, 140 edges>
+gap> IsRegularDigraph(D);
+true
+gap> ChromaticNumber(D);
+3
+gap> CliqueNumber(D);
+2]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="LindgrenSousselierGraph">
+<ManSection>
+  <Oper Name="LindgrenSousselierGraph" Arg="[filt, ]n"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is an integer greater than 0, then this operation returns the
+    <A>n</A>th <E>Lindgren-Sousselier graph</E>, an infinite family of
+    hyophamiltonian graphs - a graph that is non-Hamiltonian but removing
+    any vector gives a Hamiltonian graph. The graph has <C>6<A>n</A>+4</C>
+    vertices and <C>15 + 10(<A>n</A>-1)</C> undirected edges. The first
+    Lindgren-Sousselier graph is the Petersen graph, and is in fact the smallest
+    hyophamiltonian graph.<P/>
+
+    See <URL>https://mathworld.wolfram.com/HypohamiltonianGraph.html</URL>
+    for further details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := LindgrenSousselierGraph(3);
+<immutable symmetric digraph with 22 vertices, 70 edges>
+gap> IsHamiltonianDigraph(D);
+false
+gap> IsHamiltonianDigraph(DigraphRemoveVertex(D, 1));
+true
+gap> IsIsomorphicDigraph(LindgrenSousselierGraph(1), PetersenGraph());
+true]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="MobiusLadderGraph">
+<ManSection>
+  <Oper Name="MobiusLadderGraph" Arg="[filt, ]n"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is a positive integer at least 4, then this operation returns
+    the <E>Mobius ladder graph</E> that is obtained by introducing a 'twist'
+    in the <A>n</A>th prism graph, similar to the construction of a Mobius
+    strip. The Mobius ladder graph is isomorphic to the circulant graph
+    <C>Ci(2<A>n</A>, [1, <A>n</A>])</C>. The Mobius ladders are cubic,
+    symmetric, Hamiltonian, vertex-transitive, and graceful. They are also
+    non-planar and apex, meaning removing a single vertex produces a planar
+    graph.<P/>
+
+    See <URL>https://mathworld.wolfram.com/MoebiusLadder.html</URL> for further
+    details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := MobiusLadderGraph(7);
+<immutable symmetric digraph with 14 vertices, 42 edges>
+gap> IsHamiltonianDigraph(D);
+true
+gap> IsVertexTransitive(D);
+true
+gap> IsPlanarDigraph(D);
+false
+gap> D2 := DigraphRemoveVertex(D, 1);
+<immutable digraph with 13 vertices, 36 edges>
+gap> IsPlanarDigraph(D2);
+true]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="MycielskiGraph">
+<ManSection>
+  <Oper Name="MycielskiGraph" Arg="[filt, ]n"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is an integer greater than 1, then this operation returns the
+    <A>n</A>th <E>Mycielski graph</E>. The Mycielskian of a triangle-free graph
+    is a construction that adds vertices and edges to produce a new graph that
+    is still triangle-free but has a larger chromatic number. The Mycielski
+    graphs are a series of graphs with this construction repeated, starting
+    with the complete graph on two vertices. The graph has <C>3 * 2^(<A>n</A>-2)
+    - 1</C> vertices, with the number of edges being
+    <C>(18 - 27 * 2 ^ <A>n</A> + 14 * 3 ^ <A>n</A>) / 36</C>.<P/>
+
+    The Mycielski graph has chromatic number equal to <A>n</A>, clique number
+    equal to <M>2</M>, and is Hamiltonian. The graph is in fact the graph with
+    chromatic number <A>n</A> with the least possible vertices.<P/>
+
+    See <URL>https://mathworld.wolfram.com/MycielskiGraph.html</URL> for further
+    details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := MycielskiGraph(4);
+<immutable Hamiltonian connected symmetric digraph with 11 vertices, 4\
+0 edges>
+gap> ChromaticNumber(D);
+4
+gap> CliqueNumber(D);
+2]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="OddGraph">
+<ManSection>
+  <Oper Name="OddGraph" Arg="[filt, ]n"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is an integer greater than 0, then this operation returns the
+    <A>n</A>th <E>odd graph</E>. The odd graph has vertices labelled with the
+    <C><A>n</A>-1</C>-subsets of a <C>2<A>n</A>-1</C>-set, with two vertices
+    adjacent if and only if their subsets are disjoint. The <A>n</A>th odd graph
+    is the <C>(2<A>n</A>-1, <A>n</A>-1)</C>-th Kneser graph. The graph has
+    <C>Binomial(2<A>n</A>-1, <A>n</A>-1)</C> vertices and <C><A>n</A> *
+    Binomial(2<A>n</A>-1, <A>n</A>-1) / 2</C> edges.<P/>
+
+    The odd graph is regular and distance transitive (and therefore distance
+    regular). They have chromatic number equal to 3, and all Odd graphs with
+    <A>n</A> greater than 3 are Hamiltonian. They are also vertex and edge
+    transitive.<P/>
+
+    See <URL>https://mathworld.wolfram.com/OddGraph.html</URL> for further
+    details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := OddGraph(4);
+<immutable edge- and vertex-transitive symmetric digraph with 35 verti\
+ces, 140 edges>
+gap> IsIsomorphicDigraph(D, KneserGraph(7, 3));
+true
+gap> ChromaticNumber(D);
+3]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="PathGraph">
+<ManSection>
+  <Oper Name="PathGraph" Arg="[filt, ]n"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is a non-negative integer then this operation returns the
+    <A>n</A>th <E>path graph</E>, consisting of the path on <A>n</A> vertices.
+    This is the symmetric closure of the <Ref Oper="ChainDigraph"/>. The path
+    graph has <A>n</A> vertices and <C><A>n</A>-1</C> edges. The path graph is
+    an undirected tree.<P/>
+
+    See <URL>https://mathworld.wolfram.com/PathGraph.html</URL> for
+    further details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := PathGraph(12);
+<immutable undirected tree digraph with 12 vertices>]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="PermutationStarGraph">
+<ManSection>
+  <Oper Name="PermutationStarGraph" Arg="[filt, ]n, k"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is an integer at greater than 0 and <A>k</A> is an integer
+    greater than 1, and <A>k</A> less than or equal to <A>n</A>, then this
+    operation returns the <C>(<A>n</A>, <A>k</A>)</C>-th <E>permutation star
+    graph</E>. The vertices of the graph are given by the <A>k</A>-length
+    ordered subsets of an <A>n</A>-set, with two vertices being adjacent if one
+    is labelled <C>p1 p2 p3 ... pi ... p<A>k</A></C>, and the other is either
+    labelled <C>pi p2 p3 ... p1 ... p<A>k</A></C>, or labelled
+    <C>x p2 p3 ... pi ... p<A>k</A></C> where <C>x</C> is in
+    <C>[1..<A>n</A>]</C> and is not equal to <C>p1</C>. The graph has
+    <C><A>n</A>! / (<A>n</A> - <A>k</A>)!</C> vertices.<P/>
+
+    The permutation star graph is regular and vertex transitive. It has diameter
+    <C>2<A>k</A> - 1</C> if <A>k</A> less than or equal to <C>Int(<A>n</A> /
+    2)</C>, and diameter <C>Int((<A>n</A> - 1) / 2) + <A>k</A></C> if
+    <C><A>k</A> >= Int(<A>n</A> / 2) + 1</C>.<P/>
+
+    See <URL>https://mathworld.wolfram.com/PermutationStarGraph.html</URL> for
+    further details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := PermutationStarGraph(6, 2);
+<immutable vertex-transitive symmetric digraph with 30 vertices, 150 e\
+dges>
+gap> DigraphDiameter(D);
+3]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="PrismGraph">
+<ManSection>
+  <Oper Name="PrismGraph" Arg="[filt, ]n"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is a positive integer at least 3, then this operation returns
+    the <E>prism graph</E> that is the skeleton of the <A>n</A>-prism. It has
+    <C>2<A>n</A></C> vertices and <C>3<A>n</A></C> undirected edges. The prism
+    graph is a symmetric digraph. The <A>n</A>th prism graph is isomorphic to
+    the graph Cartesian product of the second path graph and the <A>n</A>th
+    cycle graph, isomorphic to the generalised Petersen graph
+    <C>GP(<A>n</A>,1)</C>. If <A>n</A> is odd then the prism graph is isomorphic
+    to the Circulant graph <C>Ci(2<A>n</A>, [2,<A>n</A>])</C>. The prism graph
+    is Hamiltonian.<P/>
+
+    See <URL>https://mathworld.wolfram.com/PrismGraph.html</URL> for further
+    details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := PrismGraph(4);
+<immutable symmetric digraph with 8 vertices, 24 edges>
+gap> IsHamiltonianDigraph(D);
+true
+gap> D := PrismGraph(5);
+<immutable symmetric digraph with 10 vertices, 30 edges>
+gap> IsIsomorphicDigraph(D, CirculantGraph(10, [2, 5]));
+true]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="StackedPrismGraph">
+<ManSection>
+  <Oper Name="StackedPrismGraph" Arg="[filt, ]n, k"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is an integer at least 3 and <A>k</A> is a positive integer then
+    this operation returns the <C>(<A>n</A>,<A>k</A>)</C>-th <E>stacked prism
+    graph</E>. The graph is <A>k</A> concentric <A>n</A>-Cycle graphs connected
+    by spokes.  The stacked prism is the graph Cartesian product of the
+    <A>n</A>th cycle graph and the <A>k</A>th path graph. The graph has
+    <C><A>n</A><A>k</A></C> vertices and <C><A>n</A>(2<A>k</A> - 1)</C>
+    undirected edges. If <A>k</A> is 1 then the graph is the <A>n</A>th cycle
+    graph, if <A>k</A> is 2 then the graph is the prism graph.
+     <P/>
+
+    See <URL>https://mathworld.wolfram.com/StackedPrismGraph.html</URL> for
+    further details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := StackedPrismGraph(5, 2);
+<immutable symmetric digraph with 10 vertices, 30 edges>
+gap> IsIsomorphicDigraph(D, PrismGraph(5));
+true]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="WalshHadamardGraph">
+<ManSection>
+  <Oper Name="WalshHadamardGraph" Arg="[filt, ]n"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is a positive integer at least 1, then this operation returns
+    the <E>Hadamard graph</E> constructed from the <A>n</A>th Hadamard matrix
+    (of dimension <C>2^<A>n</A></C>) as constructed by Joseph Walsh. A Hadamard
+    matrix is a square matrix with entries either <M>1</M> or <M>-1</M>, such
+    that all the rows are mutually orthogonal. The <A>n</A>th Walsh Hadamard
+    graph is a graph on <C>4<A>n</A></C> matrices split into four categories
+    <M>r_i+, r_i-, c_i+, c_i-</M>.  If <M>h_ij</M> are the elements of the
+    <A>n</A>th Walsh matrix, then if <M>h_ij = 1</M> then <M>(r_i+, c_j+)</M>
+    and <M>(r_i-, c_j-)</M> are edges, if <M>h_ij = -1</M> then <M>(r_i+,
+    c_j-)</M> and <M>(r_i-, c_j+)</M> are edges. Walsh Hadamard graphs are
+    distance transitive and distance regular.<P/>
+
+    See <URL>https://mathworld.wolfram.com/HadamardGraph.html</URL> for further
+    details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := WalshHadamardGraph(5);
+<immutable symmetric digraph with 64 vertices, 1024 edges>
+gap> IsDistanceRegularDigraph(D);
+true]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="WebGraph">
+<ManSection>
+  <Oper Name="WebGraph" Arg="[filt, ]n"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is an integer at least 3 then this operation returns the
+    <A>n</A>th <E>web graph</E>. The web graph is the <C>(<A>n</A>,3)</C>-th
+    stacked prism graph with the edges of the outer cycle removed. The graph
+    has <C>3<A>n</A></C> vertices and <C>4<A>n</A></C> undirected edges.<P/>
+
+    See <URL>https://mathworld.wolfram.com/WebGraph.html</URL> for
+    further details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := WebGraph(5);
+<immutable symmetric digraph with 15 vertices, 40 edges>]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="WheelGraph">
+<ManSection>
+  <Oper Name="WheelGraph" Arg="[filt, ]n"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> is a positive integer at least 4, then this operation returns
+    the <A>n</A>th <E>wheel graph</E>. The Wheel graph is formed from an
+    <C><A>n</A>-1</C> cycle graph with a single additional vertex adjacent to
+    all vertices of the cycle. The graph has <A>n</A> vertices and
+    <C>2(<A>n</A>-1)</C> edges. Wheel graphs are the skeletons of
+    <C><A>n</A>-1</C> pyramids, and are self-dual. If <A>n</A> is odd, then the
+    chromatic number of the wheel graph is 3 and the Wheel graph is perfect, and
+    it is 4 otherwise. The wheel graph is also Hamiltonian and planar.<P/>
+
+    See <URL>https://mathworld.wolfram.com/WheelGraph.html</URL> for further
+    details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := WheelGraph(8);
+<immutable Hamiltonian connected symmetric digraph with 8 vertices, 28\
+ edges>
+gap> ChromaticNumber(D);
+4
+gap> IsHamiltonianDigraph(D);
+true]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
+<#GAPDoc Label="WindmillGraph">
+<ManSection>
+  <Oper Name="WindmillGraph" Arg="[filt, ]n, m"/>
+  <Returns>A digraph.</Returns>
+  <Description>
+    If <A>n</A> and <A>m</A> are integers greater than 1 then this operation
+    returns the <C>(<A>n</A>, <A>m</A>)</C>-th <E>windmill graph</E>. The
+    windmill graph is formed from <A>m</A> copies of the complete graph on
+    <A>n</A> vertices with one shared vertex. The graph has <C><A>m</A>(<A>n</A>
+    - 1) + 1</C> vertices and <C><A>m</A> * <A>n</A> * (<A>n</A> - 1) / 2</C>
+    undirected edges. The windmill graph has chromatic number <A>n</A> and
+    diameter 2.<P/>
+
+    See <URL>https://mathworld.wolfram.com/WindmillGraph.html</URL> for
+    further details.<P/>
+
+    &STANDARD_FILT_TEXT;
+
+<Example><![CDATA[
+gap> D := WindmillGraph(4, 3);
+<immutable symmetric digraph with 10 vertices, 36 edges>
+gap> ChromaticNumber(D);
+4]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
diff --git a/doc/z-chap2.xml b/doc/z-chap2.xml
index f3ed23c9e..a65e24a41 100644
--- a/doc/z-chap2.xml
+++ b/doc/z-chap2.xml
@@ -108,6 +108,30 @@
     <#Include Label="BookGraph">
     <#Include Label="StackedBookGraph">
     <#Include Label="BinaryTree">
+    <#Include Label="AndrasfaiGraph">
+    <#Include Label="BinomialTreeGraph">
+    <#Include Label="BondyGraph">
+    <#Include Label="CirculantGraph">
+    <#Include Label="CycleGraph">
+    <#Include Label="GearGraph">
+    <#Include Label="HalvedCubeGraph">
+    <#Include Label="HanoiGraph">
+    <#Include Label="HelmGraph">
+    <#Include Label="HypercubeGraph">
+    <#Include Label="KellerGraph">
+    <#Include Label="KneserGraph">
+    <#Include Label="LindgrenSousselierGraph">
+    <#Include Label="MobiusLadderGraph">
+    <#Include Label="MycielskiGraph">
+    <#Include Label="OddGraph">
+    <#Include Label="PathGraph">
+    <#Include Label="PermutationStarGraph">
+    <#Include Label="PrismGraph">
+    <#Include Label="StackedPrismGraph">
+    <#Include Label="WalshHadamardGraph">
+    <#Include Label="WebGraph">
+    <#Include Label="WheelGraph">
+    <#Include Label="WindmillGraph">
   </Section>
 
 </Chapter>
diff --git a/gap/examples.gd b/gap/examples.gd
index 7fa7cf9dc..108318897 100644
--- a/gap/examples.gd
+++ b/gap/examples.gd
@@ -118,3 +118,99 @@ DeclareOperation("StackedBookGraph", [IsFunction, IsPosInt, IsPosInt]);
 DeclareConstructor("BinaryTreeCons", [IsDigraph, IsPosInt]);
 DeclareOperation("BinaryTree", [IsPosInt]);
 DeclareOperation("BinaryTree", [IsFunction, IsPosInt]);
+
+DeclareConstructor("AndrasfaiGraphCons", [IsDigraph, IsPosInt]);
+DeclareOperation("AndrasfaiGraph", [IsPosInt]);
+DeclareOperation("AndrasfaiGraph", [IsFunction, IsPosInt]);
+
+DeclareConstructor("BinomialTreeGraphCons", [IsDigraph, IsPosInt]);
+DeclareOperation("BinomialTreeGraph", [IsPosInt]);
+DeclareOperation("BinomialTreeGraph", [IsFunction, IsPosInt]);
+
+DeclareConstructor("BondyGraphCons", [IsDigraph, IsInt]);
+DeclareOperation("BondyGraph", [IsInt]);
+DeclareOperation("BondyGraph", [IsFunction, IsInt]);
+
+DeclareConstructor("CirculantGraphCons", [IsDigraph, IsPosInt, IsList]);
+DeclareOperation("CirculantGraph", [IsPosInt, IsList]);
+DeclareOperation("CirculantGraph", [IsFunction, IsPosInt, IsList]);
+
+DeclareConstructor("CycleGraphCons", [IsDigraph, IsPosInt]);
+DeclareOperation("CycleGraph", [IsPosInt]);
+DeclareOperation("CycleGraph", [IsFunction, IsPosInt]);
+
+DeclareConstructor("GearGraphCons", [IsDigraph, IsPosInt]);
+DeclareOperation("GearGraph", [IsPosInt]);
+DeclareOperation("GearGraph", [IsFunction, IsPosInt]);
+
+DeclareConstructor("HalvedCubeGraphCons", [IsDigraph, IsPosInt]);
+DeclareOperation("HalvedCubeGraph", [IsPosInt]);
+DeclareOperation("HalvedCubeGraph", [IsFunction, IsPosInt]);
+
+DeclareConstructor("HanoiGraphCons", [IsDigraph, IsPosInt]);
+DeclareOperation("HanoiGraph", [IsPosInt]);
+DeclareOperation("HanoiGraph", [IsFunction, IsPosInt]);
+
+DeclareConstructor("HelmGraphCons", [IsDigraph, IsPosInt]);
+DeclareOperation("HelmGraph", [IsPosInt]);
+DeclareOperation("HelmGraph", [IsFunction, IsPosInt]);
+
+DeclareConstructor("HypercubeGraphCons", [IsDigraph, IsInt]);
+DeclareOperation("HypercubeGraph", [IsInt]);
+DeclareOperation("HypercubeGraph", [IsFunction, IsInt]);
+
+DeclareConstructor("KellerGraphCons", [IsDigraph, IsInt]);
+DeclareOperation("KellerGraph", [IsInt]);
+DeclareOperation("KellerGraph", [IsFunction, IsInt]);
+
+DeclareConstructor("KneserGraphCons", [IsDigraph, IsPosInt, IsPosInt]);
+DeclareOperation("KneserGraph", [IsPosInt, IsPosInt]);
+DeclareOperation("KneserGraph", [IsFunction, IsPosInt, IsPosInt]);
+
+DeclareConstructor("LindgrenSousselierGraphCons", [IsDigraph, IsPosInt]);
+DeclareOperation("LindgrenSousselierGraph", [IsPosInt]);
+DeclareOperation("LindgrenSousselierGraph", [IsFunction, IsPosInt]);
+
+DeclareConstructor("MobiusLadderGraphCons", [IsDigraph, IsPosInt]);
+DeclareOperation("MobiusLadderGraph", [IsPosInt]);
+DeclareOperation("MobiusLadderGraph", [IsFunction, IsPosInt]);
+
+DeclareConstructor("MycielskiGraphCons", [IsDigraph, IsPosInt]);
+DeclareOperation("MycielskiGraph", [IsPosInt]);
+DeclareOperation("MycielskiGraph", [IsFunction, IsPosInt]);
+
+DeclareConstructor("OddGraphCons", [IsDigraph, IsInt]);
+DeclareOperation("OddGraph", [IsInt]);
+DeclareOperation("OddGraph", [IsFunction, IsInt]);
+
+DeclareConstructor("PathGraphCons", [IsDigraph, IsPosInt]);
+DeclareOperation("PathGraph", [IsPosInt]);
+DeclareOperation("PathGraph", [IsFunction, IsPosInt]);
+
+DeclareConstructor("PermutationStarGraphCons", [IsDigraph, IsPosInt, IsInt]);
+DeclareOperation("PermutationStarGraph", [IsPosInt, IsInt]);
+DeclareOperation("PermutationStarGraph", [IsFunction, IsPosInt, IsInt]);
+
+DeclareConstructor("PrismGraphCons", [IsDigraph, IsPosInt]);
+DeclareOperation("PrismGraph", [IsPosInt]);
+DeclareOperation("PrismGraph", [IsFunction, IsPosInt]);
+
+DeclareConstructor("StackedPrismGraphCons", [IsDigraph, IsPosInt, IsPosInt]);
+DeclareOperation("StackedPrismGraph", [IsPosInt, IsPosInt]);
+DeclareOperation("StackedPrismGraph", [IsFunction, IsPosInt, IsPosInt]);
+
+DeclareConstructor("WalshHadamardGraphCons", [IsDigraph, IsPosInt]);
+DeclareOperation("WalshHadamardGraph", [IsPosInt]);
+DeclareOperation("WalshHadamardGraph", [IsFunction, IsPosInt]);
+
+DeclareConstructor("WebGraphCons", [IsDigraph, IsPosInt]);
+DeclareOperation("WebGraph", [IsPosInt]);
+DeclareOperation("WebGraph", [IsFunction, IsPosInt]);
+
+DeclareConstructor("WheelGraphCons", [IsDigraph, IsPosInt]);
+DeclareOperation("WheelGraph", [IsPosInt]);
+DeclareOperation("WheelGraph", [IsFunction, IsPosInt]);
+
+DeclareConstructor("WindmillGraphCons", [IsDigraph, IsPosInt, IsPosInt]);
+DeclareOperation("WindmillGraph", [IsPosInt, IsPosInt]);
+DeclareOperation("WindmillGraph", [IsFunction, IsPosInt, IsPosInt]);
diff --git a/gap/examples.gi b/gap/examples.gi
index 4e60a8e55..c636306eb 100644
--- a/gap/examples.gi
+++ b/gap/examples.gi
@@ -989,3 +989,907 @@ depth -> BinaryTreeCons(IsImmutableDigraph, depth));
 
 InstallMethod(BinaryTree, "for a function and a positive integer",
 [IsFunction, IsPosInt], BinaryTreeCons);
+
+InstallMethod(AndrasfaiGraphCons, "for IsMutableDigraph and an integer",
+[IsMutableDigraph, IsPosInt],
+function(filt, n)
+  local js;
+  js := List([0 .. (n - 1)], x -> (3 * x) + 1);
+  return CirculantGraph(IsMutableDigraph, (3 * n) - 1, js);
+end);
+
+InstallMethod(AndrasfaiGraphCons,
+"for IsImmutableDigraph, integer",
+[IsImmutableDigraph, IsPosInt],
+function(filt, n)
+  local D;
+  D := MakeImmutable(AndrasfaiGraphCons(IsMutableDigraph, n));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  SetIsUndirectedTree(D, false);
+  SetIsRegularDigraph(D, true);
+  SetIsVertexTransitive(D, true);
+  SetIsHamiltonianDigraph(D, true);
+  SetIsBiconnectedDigraph(D, true);
+  return D;
+end);
+
+InstallMethod(AndrasfaiGraph, "for an integer", [IsPosInt],
+n -> AndrasfaiGraphCons(IsImmutableDigraph, n));
+
+InstallMethod(AndrasfaiGraph, "for a function and an integer",
+[IsFunction, IsPosInt], AndrasfaiGraphCons);
+
+InstallMethod(BinomialTreeGraphCons, "for IsMutableDigraph and an integer",
+[IsMutableDigraph, IsPosInt],
+function(filt, n)
+  local bits, is2n, verts, D, rep, pos, parent, parVert, i;
+  bits := Log(n, 2);
+  is2n := IsEvenInt(n) and IsPrimePowerInt(n);
+  if not is2n then
+    bits := bits + 1;
+  fi;
+  verts := List(Tuples([0, 1], bits){[1 .. n]},
+                x -> x{List([1 .. bits], y -> bits - y + 1)});
+  D := Digraph(IsMutableDigraph, []);
+  DigraphAddVertices(D, n);
+  for i in [2 .. n] do  # 1 is the root vertex
+    rep := StructuralCopy(verts[i]);
+    pos := Position(rep, 1);
+    parent := rep;
+    parent[pos] := 0;
+    parVert := Position(verts, parent);
+    DigraphAddEdge(D, i, parVert);
+  od;
+
+  return DigraphSymmetricClosure(DigraphRemoveAllMultipleEdges(D));
+end);
+
+InstallMethod(BinomialTreeGraphCons,
+"for IsImmutableDigraph, integer",
+[IsImmutableDigraph, IsPosInt],
+function(filt, n)
+  local D;
+  D := MakeImmutable(BinomialTreeGraphCons(IsMutableDigraph, n));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  SetIsEmptyDigraph(D, n = 1);
+  SetIsUndirectedTree(D, true);
+  return D;
+end);
+
+InstallMethod(BinomialTreeGraph, "for an integer", [IsPosInt],
+n -> BinomialTreeGraphCons(IsImmutableDigraph, n));
+
+InstallMethod(BinomialTreeGraph, "for a function and an integer",
+[IsFunction, IsPosInt], BinomialTreeGraphCons);
+
+InstallMethod(BondyGraphCons, "for IsMutableDigraph and an integer",
+[IsMutableDigraph, IsInt],
+function(filt, n)
+  if n < 0 then
+    ErrorNoReturn("the argument <n> must be a non-negative integer,");
+  fi;
+  return GeneralisedPetersenGraph(IsMutableDigraph, 3 * (2 * n + 1) + 2, 2);
+end);
+
+InstallMethod(BondyGraphCons,
+"for IsImmutableDigraph, integer",
+[IsImmutableDigraph, IsInt],
+function(filt, n)
+  local D;
+  D := MakeImmutable(BondyGraphCons(IsMutableDigraph, n));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  SetIsHamiltonianDigraph(D, false);
+  return D;
+end);
+
+InstallMethod(BondyGraph, "for an integer", [IsInt],
+n -> BondyGraphCons(IsImmutableDigraph, n));
+
+InstallMethod(BondyGraph, "for a function and an integer",
+[IsFunction, IsInt], BondyGraphCons);
+
+InstallMethod(CirculantGraphCons, "for IsMutableDigraph, an integer and a list",
+[IsMutableDigraph, IsPosInt, IsList],
+function(filt, n, par)
+  local D, i, j;
+  if (n < 2) or (not ForAll(par, x -> IsInt(x) and x in [1 .. n])) then
+    ErrorNoReturn("arguments must be an integer <n> greater ",
+                  "than 1 and a list of integers between 1 and n,");
+  fi;
+  D := Digraph(IsMutableDigraph, []);
+  DigraphAddVertices(D, n);
+  for i in [1 .. n] do
+    for j in par do
+      if (i - j) mod n = 0 then
+        DigraphAddEdge(D, i, n);
+      else
+        DigraphAddEdge(D, i, (i - j) mod n);
+      fi;
+      if (i + j) mod n = 0 then
+        DigraphAddEdge(D, i, n);
+      else
+        DigraphAddEdge(D, i, (i + j) mod n);
+      fi;
+    od;
+  od;
+  return DigraphRemoveAllMultipleEdges(DigraphSymmetricClosure(D));
+end);
+
+InstallMethod(CirculantGraphCons,
+"for IsImmutableDigraph, integer, list of integers",
+[IsImmutableDigraph, IsPosInt, IsList],
+function(filt, n, par)
+  local D;
+  D := MakeImmutable(CirculantGraphCons(IsMutableDigraph, n, par));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  SetIsUndirectedTree(D, false);
+  SetIsRegularDigraph(D, true);
+  SetIsVertexTransitive(D, true);
+  SetIsHamiltonianDigraph(D, true);
+  SetIsBiconnectedDigraph(D, true);
+  return D;
+end);
+
+InstallMethod(CirculantGraph, "for an integer and a list", [IsPosInt, IsList],
+{n, par} -> CirculantGraphCons(IsImmutableDigraph, n, par));
+
+InstallMethod(CirculantGraph, "for a function and an integer",
+[IsFunction, IsPosInt, IsList], CirculantGraphCons);
+
+InstallMethod(CycleGraphCons, "for IsMutableDigraph and an integer",
+[IsMutableDigraph, IsPosInt],
+function(filt, n)
+  if n < 3 then
+    ErrorNoReturn("the argument <n> must be an integer greater than 2,");
+  fi;
+  return DigraphSymmetricClosure(CycleDigraph(filt, n));
+end);
+
+InstallMethod(CycleGraphCons,
+"for IsImmutableDigraph, integer",
+[IsImmutableDigraph, IsPosInt],
+function(filt, n)
+  local D;
+  D := MakeImmutable(CycleGraphCons(IsMutableDigraph, n));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  return D;
+end);
+
+InstallMethod(CycleGraph, "for an integer", [IsPosInt],
+n -> CycleGraphCons(IsImmutableDigraph, n));
+
+InstallMethod(CycleGraph, "for a function and an integer",
+[IsFunction, IsPosInt], CycleGraphCons);
+
+InstallMethod(GearGraphCons, "for IsMutableDigraph and an integer",
+[IsMutableDigraph, IsPosInt],
+function(filt, n)
+  local D, i, central;
+  if n < 3 then
+    ErrorNoReturn("the argument <n> must be an integer greater than 2,");
+  fi;
+  central := 2 * n + 1;
+  D := CycleGraph(IsMutableDigraph, central - 1);
+  DigraphAddVertex(D);
+  for i in [1 .. n] do
+    DigraphAddEdge(D, 2 * i, central);
+    DigraphAddEdge(D, central, 2 * i);
+  od;
+  return D;
+end);
+
+InstallMethod(GearGraphCons,
+"for IsImmutableDigraph, integer",
+[IsImmutableDigraph, IsPosInt],
+function(filt, n)
+  local D;
+  D := MakeImmutable(GearGraphCons(IsMutableDigraph, n));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  return D;
+end);
+
+InstallMethod(GearGraph, "for an integer", [IsPosInt],
+n -> GearGraphCons(IsImmutableDigraph, n));
+
+InstallMethod(GearGraph, "for a function and an integer",
+[IsFunction, IsPosInt], GearGraphCons);
+
+InstallMethod(HalvedCubeGraphCons, "for IsMutableDigraph and an integer",
+[IsMutableDigraph, IsPosInt],
+function(filt, n)
+  local D, tuples, vertices, i, j;
+  tuples := Tuples([0, 1], n);
+  vertices := List([1 .. (2 ^ (n - 1))], x -> []);
+  j := 1;
+  for i in [1 .. Length(tuples)] do
+    if Sum(tuples[i]) mod 2 = 0 then
+      vertices[j] := tuples[i];
+      j := j + 1;
+    fi;
+  od;
+  D := EmptyDigraph(IsMutableDigraph, Length(vertices));
+  for i in [1 .. Length(vertices) - 1] do
+    for j in [i + 1 .. Length(vertices)] do
+      if SizeBlist(List([1 .. Length(vertices[i])],
+          x -> vertices[i][x] <> vertices[j][x])) = 2 then
+        DigraphAddEdge(D, i, j);
+        DigraphAddEdge(D, j, i);
+      fi;
+    od;
+  od;
+  return D;
+end);
+
+InstallMethod(HalvedCubeGraphCons,
+"for IsImmutableDigraph, integer",
+[IsImmutableDigraph, IsPosInt],
+function(filt, n)
+  local D;
+  D := MakeImmutable(HalvedCubeGraphCons(IsMutableDigraph, n));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  SetIsEmptyDigraph(D, n = 1);
+  SetIsDistanceRegularDigraph(D, true);
+  SetIsHamiltonianDigraph(D, true);
+  return D;
+end);
+
+InstallMethod(HalvedCubeGraph, "for an integer", [IsPosInt],
+n -> HalvedCubeGraphCons(IsImmutableDigraph, n));
+
+InstallMethod(HalvedCubeGraph, "for a function and an integer",
+[IsFunction, IsPosInt], HalvedCubeGraphCons);
+
+InstallMethod(HanoiGraphCons, "for IsMutableDigraph and an integer",
+[IsMutableDigraph, IsPosInt],
+function(filt, n)
+  local D, nrVert, prevNrVert, exp, i;
+  D := Digraph(IsMutableDigraph, []);
+  nrVert := 3 ^ n;
+  DigraphAddVertices(D, nrVert);
+  DigraphAddEdges(D, [[1, 2], [2, 3], [3, 1]]);
+  prevNrVert := 1;
+  exp := 1;
+  for i in [2 .. n] do
+    prevNrVert := prevNrVert * 3;
+    DigraphAddEdges(D, Concatenation(DigraphEdges(D) + prevNrVert,
+                                    DigraphEdges(D) + (2 * prevNrVert)));
+    DigraphAddEdge(D, prevNrVert / 2 + (1 / 2), prevNrVert + 1);
+    DigraphAddEdge(D, prevNrVert, 2 * prevNrVert + 1);
+    DigraphAddEdge(D, 2 * prevNrVert, prevNrVert * 3 - exp);
+    exp := exp * 2;
+  od;
+
+  return DigraphSymmetricClosure(D);
+end);
+
+InstallMethod(HanoiGraphCons,
+"for IsImmutableDigraph, integer",
+[IsImmutableDigraph, IsPosInt],
+function(filt, n)
+  local D;
+  D := MakeImmutable(HanoiGraphCons(IsMutableDigraph, n));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  SetIsPlanarDigraph(D, true);
+  SetIsHamiltonianDigraph(D, true);
+  return D;
+end);
+
+InstallMethod(HanoiGraph, "for an integer", [IsPosInt],
+n -> HanoiGraphCons(IsImmutableDigraph, n));
+
+InstallMethod(HanoiGraph, "for a function and an integer",
+[IsFunction, IsPosInt], HanoiGraphCons);
+
+InstallMethod(HelmGraphCons, "for IsMutableDigraph and an integer",
+[IsMutableDigraph, IsPosInt],
+function(filt, n)
+  local D;
+  if n < 3 then
+    ErrorNoReturn("the argument <n> must be an integer greater than 2,");
+  fi;
+  D := WheelGraph(IsMutableDigraph, n + 1);
+  DigraphAddVertices(D, n);
+  DigraphAddEdges(D, List([1 .. n], x -> [x, x + n + 1]));
+  DigraphSymmetricClosure(D);
+  return D;
+end);
+
+InstallMethod(HelmGraphCons,
+"for IsImmutableDigraph, integer",
+[IsImmutableDigraph, IsPosInt],
+function(filt, n)
+  local D;
+  D := MakeImmutable(HelmGraphCons(IsMutableDigraph, n));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  return D;
+end);
+
+InstallMethod(HelmGraph, "for an integer", [IsPosInt],
+n -> HelmGraphCons(IsImmutableDigraph, n));
+
+InstallMethod(HelmGraph, "for a function and an integer",
+[IsFunction, IsPosInt], HelmGraphCons);
+
+InstallMethod(HypercubeGraphCons,
+"for IsImmutableDigraph, integer",
+[IsImmutableDigraph, IsInt],
+function(filt, n)
+  local D;
+  D := MakeImmutable(HypercubeGraphCons(IsMutableDigraph, n));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  SetIsEmptyDigraph(D, n = 0);
+  SetIsHamiltonianDigraph(D, true);
+  SetIsDistanceRegularDigraph(D, true);
+  SetIsBipartiteDigraph(D, true);
+  return D;
+end);
+
+InstallMethod(HypercubeGraphCons, "for IsMutableDigraph and an integer",
+[IsMutableDigraph, IsInt],
+function(filt, n)
+  local D, vertices, i, j;
+  if n < 0 then
+    ErrorNoReturn("the argument <n> must be a non-negative integer,");
+  fi;
+  vertices := Tuples([0, 1], n);
+  D := EmptyDigraph(IsMutableDigraph, Length(vertices));
+  for i in [1 .. Length(vertices) - 1] do
+    for j in [i + 1 .. Length(vertices)] do
+      if SizeBlist(List([1 .. Length(vertices[i])],
+          x -> vertices[i][x] <> vertices[j][x])) = 1 then
+        DigraphAddEdge(D, i, j);
+        DigraphAddEdge(D, j, i);
+      fi;
+    od;
+  od;
+  return D;
+end);
+
+InstallMethod(HypercubeGraph, "for an integer", [IsInt],
+n -> HypercubeGraphCons(IsImmutableDigraph, n));
+
+InstallMethod(HypercubeGraph, "for a function and an integer",
+[IsFunction, IsInt], HypercubeGraphCons);
+
+InstallMethod(KellerGraphCons, "for IsMutableDigraph and an integer",
+[IsMutableDigraph, IsInt],
+function(filt, n)
+  local D, vertices, i, j;
+  if n < 0 then
+    ErrorNoReturn("the argument <n> must be a non-negative integer,");
+  fi;
+  vertices := Tuples([0, 1, 2, 3], n);
+  D := Digraph(IsMutableDigraph, []);
+  DigraphAddVertices(D, Length(vertices));
+  for i in [1 .. Length(vertices) - 1] do
+    for j in [i + 1 .. Length(vertices)] do
+      if SizeBlist(List([1 .. Length(vertices[i])],
+          x -> vertices[i][x] <> vertices[j][x])) > 1 and
+          SizeBlist(List([1 .. Length(vertices[i])],
+          x -> AbsInt(vertices[i][x] - vertices[j][x]) mod 4 = 2)) > 0 then
+        DigraphAddEdge(D, i, j);
+        DigraphAddEdge(D, j, i);
+      fi;
+    od;
+  od;
+  return D;
+end);
+
+InstallMethod(KellerGraphCons,
+"for IsImmutableDigraph, integer",
+[IsImmutableDigraph, IsInt],
+function(filt, n)
+  local D;
+  D := MakeImmutable(KellerGraphCons(IsMutableDigraph, n));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  if n > 1 then
+    SetChromaticNumber(D, 2 ^ n);
+    SetIsHamiltonianDigraph(D, true);
+  else
+    SetIsEmptyDigraph(D, true);
+  fi;
+  return D;
+end);
+
+InstallMethod(KellerGraph, "for an integer", [IsInt],
+n -> KellerGraphCons(IsImmutableDigraph, n));
+
+InstallMethod(KellerGraph, "for a function and an integer",
+[IsFunction, IsInt], KellerGraphCons);
+
+InstallMethod(KneserGraphCons, "for IsMutableDigraph and two integers",
+[IsMutableDigraph, IsPosInt, IsPosInt],
+function(filt, n, k)
+  local D, vertices, i, j;
+  if n < k then
+    ErrorNoReturn("argument <n> must be greater than or equal to argument <k>,");
+  fi;
+  vertices := Combinations([1 .. n], k);
+  D := EmptyDigraph(IsMutableDigraph, Length(vertices));
+  for i in [1 .. Length(vertices) - 1] do
+    for j in [i + 1 .. Length(vertices)] do
+      if Length(Intersection(vertices[i], vertices[j])) = 0 then
+        DigraphAddEdge(D, i, j);
+        DigraphAddEdge(D, j, i);
+      fi;
+    od;
+  od;
+  return D;
+end);
+
+InstallMethod(KneserGraphCons,
+"for IsImmutableDigraph, integer, integer",
+[IsImmutableDigraph, IsPosInt, IsPosInt],
+function(filt, n, k)
+  local D;
+  D := MakeImmutable(KneserGraphCons(IsMutableDigraph, n, k));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  SetIsRegularDigraph(D, true);
+  SetIsVertexTransitive(D, true);
+  SetIsEdgeTransitive(D, true);
+  if n >= 2 * k then
+    SetChromaticNumber(D, n - 2 * k + 2);
+  else
+    SetChromaticNumber(D, 1);
+    SetIsEmptyDigraph(D, true);
+  fi;
+  if Float(n) >= ((3 + 5 ^ 0.5) / 2) * Float(k) + 1 then
+    SetIsHamiltonianDigraph(D, true);
+  fi;
+  SetCliqueNumber(D, Int(n / k));
+  return D;
+end);
+
+InstallMethod(KneserGraph, "for two integers", [IsPosInt, IsPosInt],
+{n, k} -> KneserGraphCons(IsImmutableDigraph, n, k));
+
+InstallMethod(KneserGraph, "for a function and two integers",
+[IsFunction, IsPosInt, IsPosInt], KneserGraphCons);
+
+InstallMethod(LindgrenSousselierGraphCons, "for IsMutableDigraph and an integer",
+[IsMutableDigraph, IsPosInt],
+function(filt, n)
+  local D, central, i, threei;
+  central := 6 * n + 4;
+  D := CycleGraph(IsMutableDigraph, central - 1);
+  DigraphAddVertex(D);
+  for i in [0 .. (2 * n)] do
+    threei := 3 * i;
+    DigraphAddEdge(D, central, threei + 1);
+    DigraphAddEdge(D, threei + 1, central);
+    if i <> 2 * n then
+      DigraphAddEdge(D, 2 + threei, 6 + threei);
+      DigraphAddEdge(D, 6 + threei, 2 + threei);
+    fi;
+  od;
+  DigraphAddEdge(D, central - 2, 3);
+  DigraphAddEdge(D, 3, central - 2);
+  return D;
+end);
+
+InstallMethod(LindgrenSousselierGraphCons,
+"for IsImmutableDigraph, integer",
+[IsImmutableDigraph, IsPosInt],
+function(filt, n)
+  local D;
+  D := MakeImmutable(LindgrenSousselierGraphCons(IsMutableDigraph, n));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  SetIsHamiltonianDigraph(D, false);
+  return D;
+end);
+
+InstallMethod(LindgrenSousselierGraph, "for an integer", [IsPosInt],
+n -> LindgrenSousselierGraphCons(IsImmutableDigraph, n));
+
+InstallMethod(LindgrenSousselierGraph, "for a function and an integer",
+[IsFunction, IsPosInt], LindgrenSousselierGraphCons);
+
+InstallMethod(MobiusLadderGraphCons, "for IsMutableDigraph and an integer",
+[IsMutableDigraph, IsPosInt],
+function(filt, n)
+  local D, i;
+  if n < 4 then
+    ErrorNoReturn("the argument <n> must be an integer equal to 4 or more,");
+  fi;
+  D := CycleGraph(IsMutableDigraph, 2 * n);
+  for i in [1 .. n] do
+    DigraphAddEdge(D, i, i + n);
+    DigraphAddEdge(D, i + n, i);
+  od;
+  return DigraphSymmetricClosure(D);
+end);
+
+InstallMethod(MobiusLadderGraphCons,
+"for IsImmutableDigraph, integer",
+[IsImmutableDigraph, IsPosInt],
+function(filt, n)
+  local D;
+  D := MakeImmutable(MobiusLadderGraphCons(IsMutableDigraph, n));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  return D;
+end);
+
+InstallMethod(MobiusLadderGraph, "for an integer", [IsPosInt],
+n -> MobiusLadderGraphCons(IsImmutableDigraph, n));
+
+InstallMethod(MobiusLadderGraph, "for a function and an integer",
+[IsFunction, IsPosInt], MobiusLadderGraphCons);
+
+InstallMethod(MycielskiGraphCons, "for IsMutableDigraph and an integer",
+[IsMutableDigraph, IsPosInt],
+function(filt, n)
+  local D, i;
+  if n < 2 then
+    ErrorNoReturn("the argument <n> must be an integer greater than 1,");
+  fi;
+  D := Digraph(IsMutableDigraph, []);
+  DigraphAddVertices(D, 2);
+  DigraphAddEdges(D, [[1, 2], [2, 1]]);
+  for i in [3 .. n] do
+    D := DigraphMycielskian(D);
+  od;
+  return D;
+end);
+
+InstallMethod(MycielskiGraphCons,
+"for IsImmutableDigraph, integer",
+[IsImmutableDigraph, IsPosInt],
+function(filt, n)
+  local D;
+  D := MakeImmutable(MycielskiGraphCons(IsMutableDigraph, n));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  SetChromaticNumber(D, n);
+  SetCliqueNumber(D, 2);
+  SetIsHamiltonianDigraph(D, true);
+  return D;
+end);
+
+InstallMethod(MycielskiGraph, "for an integer", [IsPosInt],
+n -> MycielskiGraphCons(IsImmutableDigraph, n));
+
+InstallMethod(MycielskiGraph, "for a function and an integer",
+[IsFunction, IsPosInt], MycielskiGraphCons);
+
+InstallMethod(OddGraphCons, "for IsMutableDigraph and an integer",
+[IsMutableDigraph, IsInt],
+function(filt, n)
+  if n < 1 then
+    ErrorNoReturn("the argument <n> must be an integer greater than 0,");
+  fi;
+  return KneserGraph(IsMutableDigraph, 2 * n - 1, n - 1);
+end);
+
+InstallMethod(OddGraphCons,
+"for IsImmutableDigraph, integer",
+[IsImmutableDigraph, IsInt],
+function(filt, n)
+  local D;
+  D := MakeImmutable(OddGraphCons(IsMutableDigraph, n));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  SetIsVertexTransitive(D, true);
+  SetIsEdgeTransitive(D, true);
+  SetIsRegularDigraph(D, true);
+  SetIsDistanceRegularDigraph(D, true);
+  SetChromaticNumber(D, 3);
+  return D;
+end);
+
+InstallMethod(OddGraph, "for an integer", [IsInt],
+n -> OddGraphCons(IsImmutableDigraph, n));
+
+InstallMethod(OddGraph, "for a function and an integer",
+[IsFunction, IsInt], OddGraphCons);
+
+InstallMethod(PathGraphCons, "for IsMutableDigraph and an integer",
+[IsMutableDigraph, IsPosInt],
+function(filt, n)
+  return DigraphSymmetricClosure(ChainDigraph(IsMutableDigraph, n));
+end);
+
+InstallMethod(PathGraphCons,
+"for IsImmutableDigraph, integer",
+[IsImmutableDigraph, IsPosInt],
+function(filt, n)
+  local D;
+  D := MakeImmutable(PathGraphCons(IsMutableDigraph, n));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  SetIsUndirectedTree(D, true);
+  SetIsEmptyDigraph(D, n = 1);
+  return D;
+end);
+
+InstallMethod(PathGraph, "for an integer", [IsPosInt],
+n -> PathGraphCons(IsImmutableDigraph, n));
+
+InstallMethod(PathGraph, "for a function and an integer",
+[IsFunction, IsPosInt], PathGraphCons);
+
+InstallMethod(PermutationStarGraphCons, "for IsMutableDigraph and two integers",
+[IsMutableDigraph, IsPosInt, IsInt],
+function(filt, n, k)
+  local D, permList, vertices, bList, pos, i, j;
+  if k < 0 then
+    ErrorNoReturn("the arguments <n> and <k> must be integers, ",
+                  "with n greater than 0 and k non-negative,");
+  fi;
+  if k > n then
+    Error("the argument <n> must be greater than or equal to <k>,");
+  fi;
+  permList := PermutationsList([1 .. n]);
+  vertices := Unique(List(permList, x -> List([1 .. k], y -> x[y])));
+  D := Digraph(IsMutableDigraph, []);
+  DigraphAddVertices(D, Length(vertices));
+  for i in [1 .. Length(vertices) - 1] do
+    for j in [i + 1 .. Length(vertices)] do
+      bList := List([1 .. Length(vertices[i])],
+        x -> vertices[i][x] <> vertices[j][x]);
+      pos := Positions(bList, true);
+      if bList[1] then
+        if (SizeBlist(bList) = 2 and
+            vertices[j][pos[2]] = vertices[i][pos[1]] and
+            vertices[j][pos[1]] = vertices[i][pos[2]]) or
+            (SizeBlist(bList) = 1 and (not vertices[j][1] in vertices[i])) then
+          DigraphAddEdge(D, i, j);
+          DigraphAddEdge(D, j, i);
+        fi;
+      fi;
+    od;
+  od;
+  return D;
+end);
+
+InstallMethod(PermutationStarGraphCons,
+"for IsImmutableDigraph, integer, integer",
+[IsImmutableDigraph, IsPosInt, IsInt],
+function(filt, n, k)
+  local D;
+  D := MakeImmutable(PermutationStarGraphCons(IsMutableDigraph, n, k));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  SetIsRegularDigraph(D, true);
+  SetIsVertexTransitive(D, true);
+  if k <= Int(n / 2) then
+    SetDigraphDiameter(D, 2 * k - 1);
+  else
+    SetDigraphDiameter(D, Int((n - 1) / 2) + k);
+  fi;
+  return D;
+end);
+
+InstallMethod(PermutationStarGraph, "for two integers", [IsPosInt, IsInt],
+{n, k} -> PermutationStarGraphCons(IsImmutableDigraph, n, k));
+
+InstallMethod(PermutationStarGraph, "for a function and two integers",
+[IsFunction, IsPosInt, IsInt], PermutationStarGraphCons);
+
+InstallMethod(PrismGraphCons, "for IsMutableDigraph and an integer",
+[IsMutableDigraph, IsPosInt],
+function(filt, n)
+  local D;
+  if n < 3 then
+    ErrorNoReturn("the argument <n> must be an integer equal to 3 or more,");
+  else
+    D := GeneralisedPetersenGraph(IsMutableDigraph, n, 1);
+    return D;
+  fi;
+end);
+
+InstallMethod(PrismGraphCons,
+"for IsImmutableDigraph, integer",
+[IsImmutableDigraph, IsPosInt],
+function(filt, n)
+  local D;
+  D := MakeImmutable(PrismGraphCons(IsMutableDigraph, n));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  return D;
+end);
+
+InstallMethod(PrismGraph, "for an integer", [IsPosInt],
+n -> PrismGraphCons(IsImmutableDigraph, n));
+
+InstallMethod(PrismGraph, "for a function and an integer",
+[IsFunction, IsPosInt], PrismGraphCons);
+
+InstallMethod(StackedPrismGraphCons, "for IsMutableDigraph and two integers",
+[IsMutableDigraph, IsPosInt, IsPosInt],
+function(filt, n, k)
+  if n < 3 then
+    ErrorNoReturn("the arguments <n> and <k> must be integers, ",
+                  "with <n> greater than 2 and <k> greater than 0,");
+  fi;
+  return DigraphCartesianProduct(CycleGraph(IsMutableDigraph, n),
+          PathGraph(IsMutableDigraph, k));
+end);
+
+InstallMethod(StackedPrismGraphCons,
+"for IsImmutableDigraph, integer, integer",
+[IsImmutableDigraph, IsPosInt, IsPosInt],
+function(filt, n, k)
+  local D;
+  D := MakeImmutable(StackedPrismGraphCons(IsMutableDigraph, n, k));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  return D;
+end);
+
+InstallMethod(StackedPrismGraph, "for two integers", [IsPosInt, IsPosInt],
+{n, k} -> StackedPrismGraphCons(IsImmutableDigraph, n, k));
+
+InstallMethod(StackedPrismGraph, "for a function and two integers",
+[IsFunction, IsPosInt, IsPosInt], StackedPrismGraphCons);
+
+InstallMethod(WalshHadamardGraphCons, "for IsMutableDigraph and an integer",
+[IsMutableDigraph, IsPosInt],
+function(filt, n)
+  local H_2, H_n, i, D, j, sideHn;
+  H_2 := [[1, 1],
+          [1, -1]];
+  H_n := [[1]];
+  if n > 1 then
+    for i in [2 .. n] do
+      H_n := KroneckerProduct(H_2, H_n);
+    od;
+  fi;
+  sideHn := Length(H_n);
+  D := EmptyDigraph(IsMutableDigraph, 4 * sideHn);
+  for i in [1 .. sideHn] do
+    for j in [1 .. sideHn] do
+      if H_n[i][j] = 1 then
+        DigraphAddEdge(D, i, 2 * sideHn + j);
+        DigraphAddEdge(D, sideHn + i, 3 * sideHn + j);
+      else
+        DigraphAddEdge(D, i, 3 * sideHn + j);
+        DigraphAddEdge(D, sideHn + i, 2 * sideHn + j);
+      fi;
+    od;
+  od;
+  return DigraphSymmetricClosure(D);
+end);
+
+InstallMethod(WalshHadamardGraphCons,
+"for IsImmutableDigraph, integer",
+[IsImmutableDigraph, IsPosInt],
+function(filt, n)
+  local D;
+  D := MakeImmutable(WalshHadamardGraphCons(IsMutableDigraph, n));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  SetIsDistanceRegularDigraph(D, true);
+  return D;
+end);
+
+InstallMethod(WalshHadamardGraph, "for an integer", [IsPosInt],
+n -> WalshHadamardGraphCons(IsImmutableDigraph, n));
+
+InstallMethod(WalshHadamardGraph, "for a function and an integer",
+[IsFunction, IsPosInt], WalshHadamardGraphCons);
+
+InstallMethod(WebGraphCons, "for IsMutableDigraph and an integer",
+[IsMutableDigraph, IsPosInt],
+function(filt, n)
+  local D, i;
+  if n < 3 then
+    ErrorNoReturn("the argument <n> must be an integer greater than 2,");
+  fi;
+  D := StackedPrismGraph(IsMutableDigraph, n, 3);
+  for i in [1 .. (n - 1)] do
+    D := DigraphRemoveEdge(D, i, i + 1);
+    D := DigraphRemoveEdge(D, i + 1, i);
+  od;
+  D := DigraphRemoveEdge(D, n, 1);
+  D := DigraphRemoveEdge(D, 1, n);
+  return D;
+end);
+
+InstallMethod(WebGraphCons,
+"for IsImmutableDigraph, integer",
+[IsImmutableDigraph, IsPosInt],
+function(filt, n)
+  local D;
+  D := MakeImmutable(WebGraphCons(IsMutableDigraph, n));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  return D;
+end);
+
+InstallMethod(WebGraph, "for an integer", [IsPosInt],
+n -> WebGraphCons(IsImmutableDigraph, n));
+
+InstallMethod(WebGraph, "for a function and an integer",
+[IsFunction, IsPosInt], WebGraphCons);
+
+InstallMethod(WheelGraphCons, "for IsMutableDigraph and an integer",
+[IsMutableDigraph, IsPosInt],
+function(filt, n)
+  local D;
+  if n < 4 then
+    ErrorNoReturn("the argument <n> must be an integer greater than 3,");
+  fi;
+  D := CycleGraph(IsMutableDigraph, n - 1);
+  DigraphAddVertex(D, 1);
+  DigraphAddEdges(D, List([1 .. n - 1], x -> [x, n]));
+  DigraphAddEdges(D, List([1 .. n - 1], x -> [n, x]));
+  return D;
+end);
+
+InstallMethod(WheelGraphCons,
+"for IsImmutableDigraph, integer",
+[IsImmutableDigraph, IsPosInt],
+function(filt, n)
+  local D;
+  D := MakeImmutable(WheelGraphCons(IsMutableDigraph, n));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  SetIsHamiltonianDigraph(D, true);
+  SetIsPlanarDigraph(D, true);
+  if (n mod 2) = 1 then
+    SetChromaticNumber(D, 3);
+  else
+    SetChromaticNumber(D, 4);
+  fi;
+  return D;
+end);
+
+InstallMethod(WheelGraph, "for an integer", [IsPosInt],
+n -> WheelGraphCons(IsImmutableDigraph, n));
+
+InstallMethod(WheelGraph, "for a function and an integer",
+[IsFunction, IsPosInt], WheelGraphCons);
+
+InstallMethod(WindmillGraphCons, "for IsMutableDigraph and two integers",
+[IsMutableDigraph, IsPosInt, IsPosInt],
+function(filt, n, m)
+  local D, i, K, nrVert;
+  if m < 2 or n < 2 then
+    ErrorNoReturn("the arguments <n> and <m> must be integers greater than 1,");
+  fi;
+  D := Digraph(IsMutableDigraph, []);
+  K := CompleteDigraph(n - 1);
+  nrVert := 1 + DigraphNrVertices(K) * m;
+  DigraphAddVertices(D, nrVert);
+  for i in [0 .. (m - 1)] do
+    DigraphAddEdges(D, DigraphEdges(K) + (i * DigraphNrVertices(K)));
+  od;
+  for i in [1 .. (DigraphNrVertices(D) - 1)] do
+    DigraphAddEdge(D, i, nrVert);
+    DigraphAddEdge(D, nrVert, i);
+  od;
+  return D;
+end);
+
+InstallMethod(WindmillGraphCons,
+"for IsImmutableDigraph, integer, integer",
+[IsImmutableDigraph, IsPosInt, IsPosInt],
+function(filt, n, m)
+  local D;
+  D := MakeImmutable(WindmillGraphCons(IsMutableDigraph, n, m));
+  SetIsMultiDigraph(D, false);
+  SetIsSymmetricDigraph(D, true);
+  SetChromaticNumber(D, n);
+  SetDigraphDiameter(D, 2);
+  return D;
+end);
+
+InstallMethod(WindmillGraph, "for two integers", [IsPosInt, IsPosInt],
+{n, m} -> WindmillGraphCons(IsImmutableDigraph, n, m));
+
+InstallMethod(WindmillGraph, "for a function and two integers",
+[IsFunction, IsPosInt, IsPosInt], WindmillGraphCons);
diff --git a/tst/standard/examples.tst b/tst/standard/examples.tst
index 14507c982..d85646fb9 100644
--- a/tst/standard/examples.tst
+++ b/tst/standard/examples.tst
@@ -467,6 +467,338 @@ true
 gap> BinaryTree(4);
 <immutable digraph with 15 vertices, 14 edges>
 
+# AndrasfaiGraph
+gap> D := AndrasfaiGraph(1);
+<immutable Hamiltonian biconnected vertex-transitive symmetric digraph with 2 \
+vertices, 2 edges>
+gap> D := AndrasfaiGraph(3);
+<immutable Hamiltonian biconnected vertex-transitive symmetric digraph with 8 \
+vertices, 24 edges>
+gap> IsIsomorphicDigraph(D, MobiusLadderGraph(4));
+true
+gap> AndrasfaiGraph(0);
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `AndrasfaiGraph' on 1 arguments
+
+# BinomialTreeGraph
+gap> D := BinomialTreeGraph(6);
+<immutable undirected tree digraph with 6 vertices>
+gap> D := BinomialTreeGraph(16);
+<immutable undirected tree digraph with 16 vertices>
+gap> DigraphEdges(D);
+[ [ 1, 2 ], [ 1, 3 ], [ 1, 5 ], [ 1, 9 ], [ 2, 1 ], [ 3, 1 ], [ 3, 4 ], 
+  [ 4, 3 ], [ 5, 1 ], [ 5, 6 ], [ 5, 7 ], [ 6, 5 ], [ 7, 5 ], [ 7, 8 ], 
+  [ 8, 7 ], [ 9, 1 ], [ 9, 10 ], [ 9, 11 ], [ 9, 13 ], [ 10, 9 ], [ 11, 9 ], 
+  [ 11, 12 ], [ 12, 11 ], [ 13, 9 ], [ 13, 14 ], [ 13, 15 ], [ 14, 13 ], 
+  [ 15, 13 ], [ 15, 16 ], [ 16, 15 ] ]
+gap> BinomialTreeGraph(1);
+<immutable empty digraph with 1 vertex>
+gap> BinomialTreeGraph(0);
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `BinomialTreeGraph' on 1 arguments
+
+# BondyGraph
+gap> D := BondyGraph(2);
+<immutable symmetric digraph with 34 vertices, 102 edges>
+gap> IsIsomorphicDigraph(D, GeneralisedPetersenGraph(17, 2));
+true
+gap> BondyGraph(-1);
+Error, the argument <n> must be a non-negative integer,
+
+# CirculantGraph
+gap> D := CirculantGraph(5, [1, 2]);
+<immutable Hamiltonian biconnected vertex-transitive symmetric digraph with 5 \
+vertices, 20 edges>
+gap> IsIsomorphicDigraph(D, CompleteDigraph(5));
+true
+gap> D := CirculantGraph(6, [2, 3]);
+<immutable Hamiltonian biconnected vertex-transitive symmetric digraph with 6 \
+vertices, 18 edges>
+gap> IsIsomorphicDigraph(D, PrismGraph(3));
+true
+gap> D := CirculantGraph(4, [1]);
+<immutable Hamiltonian biconnected vertex-transitive symmetric digraph with 4 \
+vertices, 8 edges>
+gap> IsIsomorphicDigraph(D, CycleGraph(4));
+true
+gap> CirculantGraph(4, [1, 5]);
+Error, arguments must be an integer <n> greater than 1 and a list of integers \
+between 1 and n,
+gap> CirculantGraph(0, [1]);
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `CirculantGraph' on 2 arguments
+gap> D := CirculantGraph(10, [1, 5]);
+<immutable Hamiltonian biconnected vertex-transitive symmetric digraph with 10\
+ vertices, 30 edges>
+gap> IsIsomorphicDigraph(D, MobiusLadderGraph(5));
+true
+
+# CycleGraph
+gap> IsIsomorphicDigraph(CycleGraph(5), DigraphSymmetricClosure(CycleDigraph(5)));
+true
+gap> CycleGraph(2);
+Error, the argument <n> must be an integer greater than 2,
+
+# GearGraph
+gap> D := GearGraph(4);
+<immutable symmetric digraph with 9 vertices, 24 edges>
+gap> DigraphEdges(D);
+[ [ 1, 2 ], [ 1, 8 ], [ 2, 1 ], [ 2, 3 ], [ 2, 9 ], [ 3, 2 ], [ 3, 4 ], 
+  [ 4, 3 ], [ 4, 5 ], [ 4, 9 ], [ 5, 4 ], [ 5, 6 ], [ 6, 5 ], [ 6, 7 ], 
+  [ 6, 9 ], [ 7, 6 ], [ 7, 8 ], [ 8, 1 ], [ 8, 7 ], [ 8, 9 ], [ 9, 2 ], 
+  [ 9, 4 ], [ 9, 6 ], [ 9, 8 ] ]
+gap> GearGraph(2);
+Error, the argument <n> must be an integer greater than 2,
+
+# HalvedCubeGraph
+gap> HalvedCubeGraph(1);
+<immutable empty digraph with 1 vertex>
+gap> D := HalvedCubeGraph(3);
+<immutable Hamiltonian connected symmetric digraph with 4 vertices, 12 edges>
+gap> IsIsomorphicDigraph(D, CompleteDigraph(4));
+true
+gap> HalvedCubeGraph(-1);
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `HalvedCubeGraph' on 1 arguments
+
+# HanoiGraph
+gap> D := HanoiGraph(1);
+<immutable Hamiltonian connected symmetric digraph with 3 vertices, 6 edges>
+gap> IsIsomorphicDigraph(D, CycleGraph(3));
+true
+gap> HanoiGraph(4);
+<immutable Hamiltonian connected symmetric digraph with 81 vertices, 240 edges\
+>
+gap> HanoiGraph(0);
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `HanoiGraph' on 1 arguments
+
+# HelmGraph
+gap> D := HelmGraph(6);
+<immutable symmetric digraph with 13 vertices, 36 edges>
+gap> DigraphEdges(D);
+[ [ 1, 2 ], [ 1, 6 ], [ 1, 7 ], [ 1, 8 ], [ 2, 1 ], [ 2, 3 ], [ 2, 7 ], 
+  [ 2, 9 ], [ 3, 2 ], [ 3, 4 ], [ 3, 7 ], [ 3, 10 ], [ 4, 3 ], [ 4, 5 ], 
+  [ 4, 7 ], [ 4, 11 ], [ 5, 4 ], [ 5, 6 ], [ 5, 7 ], [ 5, 12 ], [ 6, 1 ], 
+  [ 6, 5 ], [ 6, 7 ], [ 6, 13 ], [ 7, 1 ], [ 7, 2 ], [ 7, 3 ], [ 7, 4 ], 
+  [ 7, 5 ], [ 7, 6 ], [ 8, 1 ], [ 9, 2 ], [ 10, 3 ], [ 11, 4 ], [ 12, 5 ], 
+  [ 13, 6 ] ]
+gap> HelmGraph(1);
+Error, the argument <n> must be an integer greater than 2,
+
+# HypercubeGraph
+gap> HypercubeGraph(0);
+<immutable empty digraph with 1 vertex>
+gap> D := HypercubeGraph(2);
+<immutable Hamiltonian connected bipartite symmetric digraph with bicomponent \
+sizes 2 and 2>
+gap> IsIsomorphicDigraph(D, CycleGraph(4));
+true
+gap> HypercubeGraph(-1);
+Error, the argument <n> must be a non-negative integer,
+
+# KellerGraph
+gap> IsIsomorphicDigraph(EmptyDigraph(4), KellerGraph(1));
+true
+gap> D := KellerGraph(2);
+<immutable Hamiltonian connected symmetric digraph with 16 vertices, 80 edges>
+gap> KellerGraph(-1);
+Error, the argument <n> must be a non-negative integer,
+
+# KneserGraph
+gap> IsIsomorphicDigraph(KneserGraph(5, 1), CompleteDigraph(5));
+true
+gap> KneserGraph(6, 3);
+<immutable edge- and vertex-transitive symmetric digraph with 20 vertices, 20 \
+edges>
+gap> KneserGraph(3, 4);
+Error, argument <n> must be greater than or equal to argument <k>,
+gap> KneserGraph(3, -1);
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `KneserGraph' on 2 arguments
+gap> KneserGraph(-1, 4);
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `KneserGraph' on 2 arguments
+gap> D := KneserGraph(5, 2);
+<immutable edge- and vertex-transitive symmetric digraph with 10 vertices, 30 \
+edges>
+gap> DigraphEdges(D);
+[ [ 1, 8 ], [ 1, 9 ], [ 1, 10 ], [ 2, 6 ], [ 2, 7 ], [ 2, 10 ], [ 3, 5 ], 
+  [ 3, 7 ], [ 3, 9 ], [ 4, 5 ], [ 4, 6 ], [ 4, 8 ], [ 5, 3 ], [ 5, 4 ], 
+  [ 5, 10 ], [ 6, 2 ], [ 6, 4 ], [ 6, 9 ], [ 7, 2 ], [ 7, 3 ], [ 7, 8 ], 
+  [ 8, 1 ], [ 8, 4 ], [ 8, 7 ], [ 9, 1 ], [ 9, 3 ], [ 9, 6 ], [ 10, 1 ], 
+  [ 10, 2 ], [ 10, 5 ] ]
+gap> D := KneserGraph(6, 4);
+<immutable empty digraph with 15 vertices>
+gap> ChromaticNumber(D);
+1
+gap> D := KneserGraph(10, 2);
+<immutable Hamiltonian connected edge- and vertex-transitive symmetric digraph\
+ with 45 vertices, 1260 edges>
+
+# LindgrenSousselierGraph
+gap> D := LindgrenSousselierGraph(1);
+<immutable symmetric digraph with 10 vertices, 30 edges>
+gap> AutomorphismGroup(D) = Group([(4, 8)(5, 7)(9, 10), (2, 10, 9)(3, 4, 5, 6, 7, 8), (1, 2, 3, 4, 10)(5, 7, 9, 6, 8)]);
+true
+gap> LindgrenSousselierGraph(0);
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `LindgrenSousselierGraph' on 1 arguments
+gap> LindgrenSousselierGraph(3);
+<immutable symmetric digraph with 22 vertices, 70 edges>
+gap> IsIsomorphicDigraph(LindgrenSousselierGraph(1), GeneralisedPetersenGraph(5, 2));
+true
+
+# MobiusLadderGraph
+gap> MobiusLadderGraph(2);
+Error, the argument <n> must be an integer equal to 4 or more,
+gap> D := MobiusLadderGraph(4);
+<immutable symmetric digraph with 8 vertices, 24 edges>
+gap> DigraphEdges(D);
+[ [ 1, 2 ], [ 1, 8 ], [ 1, 5 ], [ 2, 1 ], [ 2, 3 ], [ 2, 6 ], [ 3, 2 ], 
+  [ 3, 4 ], [ 3, 7 ], [ 4, 3 ], [ 4, 5 ], [ 4, 8 ], [ 5, 4 ], [ 5, 6 ], 
+  [ 5, 1 ], [ 6, 5 ], [ 6, 7 ], [ 6, 2 ], [ 7, 6 ], [ 7, 8 ], [ 7, 3 ], 
+  [ 8, 1 ], [ 8, 7 ], [ 8, 4 ] ]
+gap> MobiusLadderGraph(10);
+<immutable symmetric digraph with 20 vertices, 60 edges>
+
+# MycielskiGraph
+gap> D := MycielskiGraph(2);
+<immutable Hamiltonian connected symmetric digraph with 2 vertices, 2 edges>
+gap> IsIsomorphicDigraph(MycielskiGraph(3), CycleGraph(5));
+true
+gap> MycielskiGraph(1);
+Error, the argument <n> must be an integer greater than 1,
+
+# OddGraph
+gap> IsIsomorphicDigraph(OddGraph(2), CycleGraph(3));
+true
+gap> OddGraph(4);
+<immutable edge- and vertex-transitive symmetric digraph with 35 vertices, 140\
+ edges>
+gap> OddGraph(0);
+Error, the argument <n> must be an integer greater than 0,
+
+# PathGraph
+gap> D := PathGraph(4);
+<immutable undirected tree digraph with 4 vertices>
+gap> IsIsomorphicDigraph(D, DigraphSymmetricClosure(ChainDigraph(4)));
+true
+gap> PathGraph(1);
+<immutable empty digraph with 1 vertex>
+gap> PathGraph(0);
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `PathGraph' on 1 arguments
+
+# PermutationStarGraph
+gap> D := PermutationStarGraph(3, 2);
+<immutable vertex-transitive symmetric digraph with 6 vertices, 12 edges>
+gap> IsIsomorphicDigraph(D, CycleGraph(6));
+true
+gap> D := PermutationStarGraph(4, 3);
+<immutable vertex-transitive symmetric digraph with 24 vertices, 72 edges>
+gap> DigraphDiameter(D);
+4
+gap> IsIsomorphicDigraph(D, GeneralisedPetersenGraph(12, 5));
+true
+gap> PermutationStarGraph(2, 4);
+Error, the argument <n> must be greater than or equal to <k>,
+gap> PermutationStarGraph(5, -1);
+Error, the arguments <n> and <k> must be integers, with n greater than 0 and k\
+ non-negative,
+gap> PermutationStarGraph(0, 2);
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `PermutationStarGraph' on 2 arguments
+
+# PrismGraph
+gap> PrismGraph(3);
+<immutable symmetric digraph with 6 vertices, 18 edges>
+gap> PrismGraph(2);
+Error, the argument <n> must be an integer equal to 3 or more,
+gap> D := PrismGraph(5);
+<immutable symmetric digraph with 10 vertices, 30 edges>
+gap> DigraphEdges(D);
+[ [ 1, 2 ], [ 1, 5 ], [ 1, 6 ], [ 2, 1 ], [ 2, 3 ], [ 2, 7 ], [ 3, 2 ], 
+  [ 3, 4 ], [ 3, 8 ], [ 4, 3 ], [ 4, 5 ], [ 4, 9 ], [ 5, 1 ], [ 5, 4 ], 
+  [ 5, 10 ], [ 6, 1 ], [ 6, 7 ], [ 6, 10 ], [ 7, 2 ], [ 7, 6 ], [ 7, 8 ], 
+  [ 8, 3 ], [ 8, 7 ], [ 8, 9 ], [ 9, 4 ], [ 9, 8 ], [ 9, 10 ], [ 10, 5 ], 
+  [ 10, 6 ], [ 10, 9 ] ]
+
+# StackedPrismGraph
+gap> D := StackedPrismGraph(4, 1);
+<immutable symmetric digraph with 4 vertices, 8 edges>
+gap> IsIsomorphicDigraph(D, CycleGraph(4));
+true
+gap> D := StackedPrismGraph(5, 2);
+<immutable symmetric digraph with 10 vertices, 30 edges>
+gap> IsIsomorphicDigraph(D, PrismGraph(5));
+true
+gap> StackedPrismGraph(3, 3);
+<immutable symmetric digraph with 9 vertices, 30 edges>
+gap> StackedPrismGraph(2, 2);
+Error, the arguments <n> and <k> must be integers, with <n> greater than 2 and\
+ <k> greater than 0,
+gap> StackedPrismGraph(3, 0);
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `StackedPrismGraph' on 2 arguments
+gap> StackedPrismGraph(0, -1);
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `StackedPrismGraph' on 2 arguments
+
+# WalshHadamardGraph
+gap> WalshHadamardGraph(1);
+<immutable symmetric digraph with 4 vertices, 4 edges>
+gap> D := WalshHadamardGraph(2);
+<immutable symmetric digraph with 8 vertices, 16 edges>
+gap> IsIsomorphicDigraph(D, CycleGraph(8));
+true
+gap> WalshHadamardGraph(0);
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `WalshHadamardGraph' on 1 arguments
+
+# WebGraph
+gap> D := WebGraph(3);
+<immutable symmetric digraph with 9 vertices, 24 edges>
+gap> DigraphEdges(D);
+[ [ 1, 4 ], [ 2, 5 ], [ 3, 6 ], [ 4, 5 ], [ 4, 6 ], [ 4, 1 ], [ 4, 7 ], 
+  [ 5, 4 ], [ 5, 6 ], [ 5, 2 ], [ 5, 8 ], [ 6, 4 ], [ 6, 5 ], [ 6, 3 ], 
+  [ 6, 9 ], [ 7, 8 ], [ 7, 9 ], [ 7, 4 ], [ 8, 7 ], [ 8, 9 ], [ 8, 5 ], 
+  [ 9, 7 ], [ 9, 8 ], [ 9, 6 ] ]
+gap> WebGraph(2);
+Error, the argument <n> must be an integer greater than 2,
+
+# WheelGraph
+gap> D := WheelGraph(5);
+<immutable Hamiltonian connected symmetric digraph with 5 vertices, 16 edges>
+gap> DigraphEdges(D);
+[ [ 1, 2 ], [ 1, 4 ], [ 1, 5 ], [ 2, 1 ], [ 2, 3 ], [ 2, 5 ], [ 3, 2 ], 
+  [ 3, 4 ], [ 3, 5 ], [ 4, 1 ], [ 4, 3 ], [ 4, 5 ], [ 5, 1 ], [ 5, 2 ], 
+  [ 5, 3 ], [ 5, 4 ] ]
+gap> WheelGraph(2);
+Error, the argument <n> must be an integer greater than 3,
+gap> ChromaticNumber(D);
+3
+gap> D := WheelGraph(6);
+<immutable Hamiltonian connected symmetric digraph with 6 vertices, 20 edges>
+gap> ChromaticNumber(D);
+4
+
+# WindmillGraph
+gap> D := WindmillGraph(3, 3);
+<immutable symmetric digraph with 7 vertices, 18 edges>
+gap> DigraphEdges(D);
+[ [ 1, 2 ], [ 1, 7 ], [ 2, 1 ], [ 2, 7 ], [ 3, 4 ], [ 3, 7 ], [ 4, 3 ], 
+  [ 4, 7 ], [ 5, 6 ], [ 5, 7 ], [ 6, 5 ], [ 6, 7 ], [ 7, 1 ], [ 7, 2 ], 
+  [ 7, 3 ], [ 7, 4 ], [ 7, 5 ], [ 7, 6 ] ]
+gap> WindmillGraph(0, 3);
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `WindmillGraph' on 2 arguments
+gap> WindmillGraph(2, 1);
+Error, the arguments <n> and <m> must be integers greater than 1,
+gap> WindmillGraph(-1, 0);
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `WindmillGraph' on 2 arguments
+
 #
 gap> DIGRAPHS_StopTest();
 gap> STOP_TEST("Digraphs package: standard/examples.tst", 0);