In this module,

Let’s define a simple parametric type for a graph:

mutable struct Graph{V, E <: Real}
    edges::Vector{Tuple{V, V}}
    weights::Vector{E}
end

In defining a Graph type, we have also defined a constructor for this graph:

diamond = Graph([(:a, :b), (:a, :c), (:b, :d), (:c, :d)], [true, true, true, true])

Main.var"##362".Graph{Symbol, Bool}([(:a, :b), (:a, :c), (:b, :d), (:c, :d)], Bool[1, 1, 1, 1])

We may be interested in making it display a little more nicely, by overloading show:

function Base.show(io::IO, g::Graph)
    return print(io, "A graph with $(length(g.edges)) $(eltype(g.weights)) edges")
end

The show method is what is called when we type in the name of a variable, and we can decide what to print as a return:

diamond

A graph with 4 Bool edges

We can now define a graph generator based on the Erdős–Rényi model – the function to do so is a good encapsulation of concepts from the previous modules, notably conditionals, the creation of struct, and list comprehensions. We will use the Combinatorics package to iterate over nodes combinations.

using Combinatorics

But generating a random graph is, in a sense, using the generator to do what we want. And so we will get a little crafty here, and define a type that represents an algorithm:

abstract type AbstractGraphGenerator end

struct ErdosRenyi <: AbstractGraphGenerator
    n::Integer
    p::AbstractFloat
end

We can now create an ER generator by giving it n (the number of nodes) and p, the probability of a connection between two nodes.

Are we closer to solving our problem? Yes! We can overload the generator for Graph in a new way, that accepts a single argument: an instance of ErdosRenyi.

function Graph(er::ErdosRenyi)
    vertices = collect(1:(er.n))
    @assert zero(er.p) <= er.p <= one(er.p)
    edges = [tuple(pair...) for pair in combinations(vertices, 2) if rand() <= er.p]
    return Graph(edges, fill(true, length(edges)))
end

Main.var"##362".Graph

We can now create a graph, and check its type:

G = Graph(ErdosRenyi(10, 0.2))

A graph with 7 Bool edges

typeof(G)

Main.var"##362".Graph{Int64, Bool}