Документация Engee

Making and Modifying Graphs

Страница в процессе перевода.

LightGraphs.jl provides a number of methods for creating a graph object, including tools for building and modifying graph objects, a wide array of graph generator functions, and the ability to read and write graphs from files (using GraphIO.jl).

Modifying graphs

LightGraphs.jl offers a range of tools for modifying graphs, including:

SimpleGraph{T}

A type representing an undirected graph.

SimpleGraphFromIterator(iter)

Create a SimpleGraph from an iterator iter. The elements in iter must be of type <: SimpleEdge.

Examples

julia> using LightGraphs

julia> g = SimpleGraph(3);

julia> add_edge!(g, 1, 2);

julia> add_edge!(g, 2, 3);

julia> h = SimpleGraphFromIterator(edges(g));

julia> collect(edges(h))
2-element Array{LightGraphs.SimpleGraphs.SimpleEdge{Int64},1}:
 Edge 1 => 2
 Edge 2 => 3
SimpleDiGraph{T}

A type representing a directed graph.

SimpleDiGraphFromIterator(iter)

Create a SimpleDiGraph from an iterator iter. The elements in iter must be of type <: SimpleEdge.

Examples

julia> using LightGraphs

julia> g = SimpleDiGraph(2);

julia> add_edge!(g, 1, 2);

julia> add_edge!(g, 2, 1);

julia> h = SimpleDiGraphFromIterator(edges(g))
{2, 2} directed simple Int64 graph

julia> collect(edges(h))
2-element Array{LightGraphs.SimpleGraphs.SimpleEdge{Int64},1}:
 Edge 1 => 2
 Edge 2 => 1
Edge

A datastruture representing an edge between two vertices in a Graph or DiGraph.

add_edge!(g, e)

Add an edge e to graph g. Return true if edge was added successfully, otherwise return false.

Examples

julia> using LightGraphs

julia> g = SimpleGraph(2);

julia> add_edge!(g, 1, 2)
true

julia> add_edge!(g, 2, 3)
false
rem_edge!(g, e)

Remove an edge e from graph g. Return true if edge was removed successfully, otherwise return false.

Implementation Notes

If rem_edge! returns false, the graph may be in an indeterminate state, as there are multiple points where the function can exit with false.

Examples

julia> using LightGraphs

julia> g = SimpleGraph(2);

julia> add_edge!(g, 1, 2);

julia> rem_edge!(g, 1, 2)
true

julia> rem_edge!(g, 1, 2)
false
add_vertex!(g)

Add a new vertex to the graph g. Return true if addition was successful.

Examples

julia> using LightGraphs

julia> g = SimpleGraph(Int8(typemax(Int8) - 1))
{126, 0} undirected simple Int8 graph

julia> add_vertex!(g)
true

julia> add_vertex!(g)
false
add_vertices!(g, n)

Add n new vertices to the graph g. Return the number of vertices that were added successfully.

Examples

julia> using LightGraphs

julia> g = SimpleGraph()
{0, 0} undirected simple Int64 graph

julia> add_vertices!(g, 2)
2
rem_vertex!(g, v)

Remove the vertex v from graph g. Return false if removal fails (e.g., if vertex is not in the graph); true otherwise.

Performance

Time complexity is , where is the max of the degrees of vertex and vertex .

Implementation Notes

This operation has to be performed carefully if one keeps external data structures indexed by edges or vertices in the graph, since internally the removal is performed swapping the vertices v and , and removing the last vertex from the graph. After removal the vertices in g will be indexed by .

Examples

julia> using LightGraphs

julia> g = SimpleGraph(2);

julia> rem_vertex!(g, 2)
true

julia> rem_vertex!(g, 2)
false
zero(G)

Return a zero-vertex, zero-edge version of the graph type G. The fallback is defined for graph values zero(g::G) = zero(G).

Examples

julia> g = SimpleDiGraph([0 1 0 0 0; 0 0 1 0 0; 1 0 0 1 0; 0 0 0 0 1; 0 0 0 1 0]);

julia> zero(typeof(g))
{0, 0} directed simple Int64 graph

julia> zero(g)
{0, 0} directed simple Int64 graph

In addition to these core functions, more advanced operators can be found in Operators.

Graph Generators

LightGraphs.jl implements numerous graph generators, including random graph generators, constructors for classic graphs, numerous small graphs with familiar topologies, and random and static graphs embedded in Euclidean space.

Datasets

Other notorious graphs and integration with the MatrixDepot.jl package are available in the Datasets submodule of the companion package LightGraphsExtras.jl. Selected graphs from the Stanford Large Network Dataset Collection may be found in the SNAPDatasets.jl package.

All Generators

SimpleDiGraph{T}(nv, ne; seed=-1)

Construct a random SimpleDiGraph{T} with nv vertices and ne edges. The graph is sampled uniformly from all such graphs. If seed >= 0, a random generator is seeded with this value. If not specified, the element type T is the type of nv.

See also

erdos_renyi

Examples

julia> SimpleDiGraph(5, 7)
{5, 7} directed simple Int64 graph
SimpleGraph{T}(nv, ne, edgestream::Channel)

Construct a SimpleGraph{T} with nv vertices and ne edges from edgestream. Can result in less than ne edges if the channel edgestream is closed prematurely. Duplicate edges are only counted once. The element type is the type of nv.

SimpleGraph{T}(nv, ne, smb::StochasticBlockModel)

Construct a random SimpleGraph{T} with nv vertices and ne edges. The graph is sampled according to the stochastic block model smb. The element type is the type of nv.

SimpleGraph{T}(nv, ne; seed=-1)

Construct a random SimpleGraph{T} with nv vertices and ne edges. The graph is sampled uniformly from all such graphs. If seed >= 0, a random generator is seeded with this value. If not specified, the element type T is the type of nv.

See also

erdos_renyi

Examples

julia> SimpleGraph(5, 7)
{5, 7} undirected simple Int64 graph
StochasticBlockModel{T,P}

A type capturing the parameters of the SBM. Each vertex is assigned to a block and the probability of edge (i,j) depends only on the block labels of vertex i and vertex j.

The assignement is stored in nodemap and the block affinities a k by k matrix is stored in affinities.

affinities[k,l] is the probability of an edge between any vertex in block k and any vertex in block l.

Implementation Notes

Graphs are generated by taking random and flipping a coin with probability affinities[nodemap[i],nodemap[j]].

barabasi_albert!(g::AbstractGraph, n::Integer, k::Integer)

Create a Barabási—​Albert model random graph with n vertices. It is grown by adding new vertices to an initial graph g. Each new vertex is attached with k edges to k different vertices already present in the system by preferential attachment.

Optional Arguments

  • seed=-1: set the RNG seed.

Examples

julia> g = cycle_graph(4)
{4, 4} undirected simple Int64 graph

julia> barabasi_albert!(g, 16, 3);

julia> g
{16, 40} undirected simple Int64 graph
barabasi_albert(n::Integer, n0::Integer, k::Integer)

Create a Barabási—​Albert model random graph with n vertices. It is grown by adding new vertices to an initial graph with n0 vertices. Each new vertex is attached with k edges to k different vertices already present in the system by preferential attachment. Initial graphs are undirected and consist of isolated vertices by default.

Optional Arguments

  • is_directed=false: if true, return a directed graph.

  • complete=false: if true, use a complete graph for the initial graph.

  • seed=-1: set the RNG seed.

Examples

julia> barabasi_albert(10, 3, 2)
{10, 14} undirected simple Int64 graph

julia> barabasi_albert(100, Int8(10), 3, is_directed=true, seed=123)
{100, 270} directed simple Int8 graph
barabasi_albert(n, k)

Create a Barabási—​Albert model random graph with n vertices. It is grown by adding new vertices to an initial graph with k vertices. Each new vertex is attached with k edges to k different vertices already present in the system by preferential attachment. Initial graphs are undirected and consist of isolated vertices by default.

Optional Arguments

  • is_directed=false: if true, return a directed graph.

  • complete=false: if true, use a complete graph for the initial graph.

  • seed=-1: set the RNG seed.

Examples

julia> barabasi_albert(50, 3)
{50, 141} undirected simple Int64 graph

julia> barabasi_albert(100, Int8(10), is_directed=true, complete=true, seed=123)
{100, 990} directed simple Int8 graph
blockcounts(sbm, A)

Count the number of edges that go between each block.

dorogovtsev_mendes(n)

Generate a random n vertex graph by the Dorogovtsev-Mendes method (with n \ge 3).

The Dorogovtsev-Mendes process begins with a triangle graph and inserts n-3 additional vertices. Each time a vertex is added, a random edge is selected and the new vertex is connected to the two endpoints of the chosen edge. This creates graphs with a many triangles and a high local clustering coefficient.

It is often useful to track the evolution of the graph as vertices are added, you can access the graph from the tth stage of this algorithm by accessing the first t vertices with g[1:t].

References

Examples

julia> dorogovtsev_mendes(10)
{10, 17} undirected simple Int64 graph

julia> dorogovtsev_mendes(11, seed=123)
{11, 19} undirected simple Int64 graph
erdos_renyi(n, ne)

Create an Erdős—​Rényi random graph with n vertices and ne edges.

Optional Arguments

  • is_directed=false: if true, return a directed graph.

  • seed=-1: set the RNG seed.

Examples

julia> erdos_renyi(10, 30)
{10, 30} undirected simple Int64 graph

julia> erdos_renyi(10, 30, is_directed=true, seed=123)
{10, 30} directed simple Int64 graph
erdos_renyi(n, p)

Create an Erdős—​Rényi random graph with n vertices. Edges are added between pairs of vertices with probability p.

Optional Arguments

  • is_directed=false: if true, return a directed graph.

  • seed=-1: set the RNG seed.

Examples

julia> erdos_renyi(10, 0.5)
{10, 20} undirected simple Int64 graph

julia> erdos_renyi(10, 0.5, is_directed=true, seed=123)
{10, 49} directed simple Int64 graph
expected_degree_graph(ω)

Given a vector of expected degrees ω indexed by vertex, create a random undirected graph in which vertices i and j are connected with probability ω[i]*ω[j]/sum(ω).

Optional Arguments

  • seed=-1: set the RNG seed.

Implementation Notes

The algorithm should work well for maximum(ω) << sum(ω). As maximum(ω) approaches sum(ω), some deviations from the expected values are likely.

References

Examples

# 1)
julia> g = expected_degree_graph([3, 1//2, 1//2, 1//2, 1//2])
{5, 3} undirected simple Int64 graph

julia> print(degree(g))
[3, 0, 1, 1, 1]

# 2)
julia> g = expected_degree_graph([0.5, 0.5, 0.5], seed=123)
{3, 1} undirected simple Int64 graph

julia> print(degree(g))
[1, 0, 1]
kronecker(SCALE, edgefactor, A=0.57, B=0.19, C=0.19; seed=-1)

Generate a directed Kronecker graph with the default Graph500 parameters.

References

make_edgestream(sbm)

Take an infinite sample from the Stochastic Block Model sbm. Pass to Graph(nvg, neg, edgestream) to get a Graph object based on sbm.

random_configuration_model(n, ks)

Create a random undirected graph according to the configuration model containing n vertices, with each node i having degree k[i].

Optional Arguments

  • seed=-1: set the RNG seed.

  • check_graphical=false: if true, ensure that k is a graphical sequence

(see isgraphical).

Performance

Time complexity is approximately .

Implementation Notes

Allocates an array of Ints.

random_orientation_dag(g)

Generate a random oriented acyclical digraph. The function takes in a simple graph and a random number generator as an argument. The probability of each directional acyclic graph randomly being generated depends on the architecture of the original directed graph.

DAG’s have a finite topological order; this order is randomly generated via "order = randperm()".

Examples

julia> random_orientation_dag(complete_graph(10))
{10, 45} directed simple Int64 graph

julia> random_orientation_dag(star_graph(Int8(10)), 123)
{10, 9} directed simple Int8 graph
random_regular_digraph(n, k)

Create a random directed regular graph with n vertices, each with degree k.

Optional Arguments

  • dir=:out: the direction of the edges for degree parameter.

  • seed=-1: set the RNG seed.

Implementation Notes

Allocates an sparse matrix of boolean as an adjacency matrix and uses that to generate the directed graph.

random_regular_graph(n, k)

Create a random undirected regular graph with n vertices, each with degree k.

Optional Arguments

  • seed=-1: set the RNG seed.

Performance

Time complexity is approximately .

Implementation Notes

Allocates an array of nk Ints, and . For , generates a graph of degree and returns its complement.

random_tournament_digraph(n)

Create a random directed tournament graph with n vertices.

Optional Arguments

  • seed=-1: set the RNG seed.

Examples

julia> random_tournament_digraph(5)
{5, 10} directed simple Int64 graph

julia> random_tournament_digraph(Int8(10), seed=123)
{10, 45} directed simple Int8 graph
static_fitness_model(m, fitness)

Generate a random graph with vertices and m edges, in which the probability of the existence of is proportional to .

Optional Arguments

  • seed=-1: set the RNG seed.

Performance

Time complexity is .

References

  • Goh K-I, Kahng B, Kim D: Universal behaviour of load distribution in scale-free networks. Phys Rev Lett 87(27):278701, 2001.

Examples

julia> g = static_fitness_model(5, [1, 1, 0.5, 0.1])
{4, 5} undirected simple Int64 graph

julia> edges(g) |> collect
5-element Array{LightGraphs.SimpleGraphs.SimpleEdge{Int64},1}:
 Edge 1 => 2
 Edge 1 => 3
 Edge 1 => 4
 Edge 2 => 3
 Edge 2 => 4
static_fitness_model(m, fitness_out, fitness_in)

Generate a random directed graph with $

fitness_out + fitness_in

$ vertices and m edges, in which the probability of the existence of is proportional with respect to and .

Optional Arguments

  • seed=-1: set the RNG seed.

Performance

Time complexity is .

References

  • Goh K-I, Kahng B, Kim D: Universal behaviour of load distribution in scale-free networks. Phys Rev Lett 87(27):278701, 2001.

Examples

julia> g = static_fitness_model(6, [1, 0.2, 0.2, 0.2], [0.1, 0.1, 0.1, 0.9]; seed=123)
{4, 6} directed simple Int64 graph

julia> edges(g) |> collect
6-element Array{LightGraphs.SimpleGraphs.SimpleEdge{Int64},1}:
 Edge 1 => 2
 Edge 1 => 3
 Edge 1 => 4
 Edge 2 => 3
 Edge 2 => 4
 Edge 3 => 4
static_scale_free(n, m, α_out, α_in)

Generate a random graph with n vertices, m edges and expected power-law degree distribution with exponent α_out for outbound edges and α_in for inbound edges.

Optional Arguments

  • seed=-1: set the RNG seed.

  • finite_size_correction=true: determines whether to use the finite size correction

proposed by Cho et al.

Performance

Time complexity is .

References

  • Goh K-I, Kahng B, Kim D: Universal behaviour of load distribution in scale-free networks. Phys Rev Lett 87(27):278701, 2001.

  • Chung F and Lu L: Connected components in a random graph with given degree sequences. Annals of Combinatorics 6, 125-145, 2002.

  • Cho YS, Kim JS, Park J, Kahng B, Kim D: Percolation transitions in scale-free networks under the Achlioptas process. Phys Rev Lett 103:135702, 2009.

static_scale_free(n, m, α)

Generate a random graph with n vertices, m edges and expected power-law degree distribution with exponent α.

Optional Arguments

  • seed=-1: set the RNG seed.

  • finite_size_correction=true: determines whether to use the finite size correction

proposed by Cho et al.

Performance

Time complexity is .

References

  • Goh K-I, Kahng B, Kim D: Universal behaviour of load distribution in scale-free networks. Phys Rev Lett 87(27):278701, 2001.

  • Chung F and Lu L: Connected components in a random graph with given degree sequences. Annals of Combinatorics 6, 125-145, 2002.

  • Cho YS, Kim JS, Park J, Kahng B, Kim D: Percolation transitions in scale-free networks under the Achlioptas process. Phys Rev Lett 103:135702, 2009.

stochastic_block_model(c, n)

Return a Graph generated according to the Stochastic Block Model (SBM).

c[a,b] : Mean number of neighbors of a vertex in block a belonging to block b. Only the upper triangular part is considered, since the lower traingular is determined by = c[a,b] * \frac{n[a]}{n[b]}]. n[a] : Number of vertices in block a

Optional Arguments

  • seed=-1: set the RNG seed.

For a dynamic version of the SBM see the StochasticBlockModel type and related functions.

stochastic_block_model(cint, cext, n)

Return a Graph generated according to the Stochastic Block Model (SBM), sampling from an SBM with , and .

watts_strogatz(n, k, β)

Return a Watts-Strogatz small model random graph with n vertices, each with degree k. Edges are randomized per the model based on probability β.

Optional Arguments

  • is_directed=false: if true, return a directed graph.

  • seed=-1: set the RNG seed.

Examples

julia> watts_strogatz(10, 4, 0.3)
{10, 20} undirected simple Int64 graph

julia> watts_strogatz(Int8(10), 4, 0.8, is_directed=true, seed=123)
{10, 20} directed simple Int8 graph
barbell_graph(n1, n2)

Create a barbell graph consisting of a clique of size n1 connected by an edge to a clique of size n2.

Implementation Notes

Preserves the eltype of n1 and n2. Will error if the required number of vertices exceeds the eltype. n1 and n2 must be at least 1 so that both cliques are non-empty. The cliques are organized with nodes 1:n1 being the left clique and n1+1:n1+n2 being the right clique. The cliques are connected by and edge (n1, n1+1).

Examples

julia> barbell_graph(3, 4)
{7, 10} undirected simple Int64 graph

julia> barbell_graph(Int8(5), Int8(5))
{10, 21} undirected simple Int8 graph
binary_tree(k::Integer)

Create a binary tree of depth k.

Examples

julia> binary_tree(4)
{15, 14} undirected simple Int64 graph

julia> binary_tree(Int8(5))
{31, 30} undirected simple Int8 graph
circular_ladder_graph(n)

Create a circular ladder graph consisting of 2n nodes and 3n edges. This is also known as the prism graph.

Implementation Notes

Preserves the eltype of the partitions vector. Will error if the required number of vertices exceeds the eltype. n must be at least 3 to avoid self-loops and multi-edges.

Examples

julia> circular_ladder_graph(3)
{6, 9} undirected simple Int64 graph

julia> circular_ladder_graph(Int8(4))
{8, 12} undirected simple Int8 graph
clique_graph(k, n)

Create a graph consisting of n connected k-cliques.

Examples

julia> clique_graph(4, 10)
{40, 70} undirected simple Int64 graph

julia> clique_graph(Int8(10), Int8(4))
{40, 184} undirected simple Int8 graph
complete_bipartite_graph(n1, n2)

Create an undirected complete bipartite graph with n1 + n2 vertices.

Examples

julia> complete_bipartite_graph(3, 4)
{7, 12} undirected simple Int64 graph

julia> complete_bipartite_graph(Int8(3), Int8(4))
{7, 12} undirected simple Int8 graph
complete_digraph(n)

Create a directed complete graph with n vertices.

Examples

julia> complete_digraph(5)
{5, 20} directed simple Int64 graph

julia> complete_digraph(Int8(6))
{6, 30} directed simple Int8 graph
complete_graph(n)

Create an undirected complete graph with n vertices.

Examples

julia> complete_graph(5)
{5, 10} undirected simple Int64 graph

julia> complete_graph(Int8(6))
{6, 15} undirected simple Int8 graph
complete_multipartite_graph(partitions)

Create an undirected complete bipartite graph with sum(partitions) vertices. A partition with 0 vertices is skipped.

Implementation Notes

Preserves the eltype of the partitions vector. Will error if the required number of vertices exceeds the eltype.

Examples

julia> complete_multipartite_graph([1,2,3])
{6, 11} undirected simple Int64 graph

julia> complete_multipartite_graph(Int8[5,5,5])
{15, 75} undirected simple Int8 graph
cycle_digraph(n)

Create a directed cycle graph with n vertices.

Examples

julia> cycle_digraph(3)
{3, 3} directed simple Int64 graph

julia> cycle_digraph(Int8(5))
{5, 5} directed simple Int8 graph
cycle_graph(n)

Create an undirected cycle graph with n vertices.

Examples

julia> cycle_graph(3)
{3, 3} undirected simple Int64 graph

julia> cycle_graph(Int8(5))
{5, 5} undirected simple Int8 graph
double_binary_tree(k::Integer)

Create a double complete binary tree with k levels.

References

  • Used as an example for spectral clustering by Guattery and Miller 1998.

Examples

julia> double_binary_tree(4)
{30, 29} undirected simple Int64 graph

julia> double_binary_tree(Int8(5))
{62, 61} undirected simple Int8 graph
grid(dims; periodic=false)

Create a -dimensional cubic lattice, with length dims[i] in dimension i.

Optional Arguments

  • periodic=false: If true, the resulting lattice will have periodic boundary

condition in each dimension.

Examples

julia> grid([2,3])
{6, 7} undirected simple Int64 graph

julia> grid(Int8[2, 2, 2], periodic=true)
{8, 12} undirected simple Int8 graph

julia> grid((2,3))
{6, 7} undirected simple Int64 graph
ladder_graph(n)

Create a ladder graph consisting of 2n nodes and 3n-2 edges.

Implementation Notes

Preserves the eltype of n. Will error if the required number of vertices exceeds the eltype.

Examples

julia> ladder_graph(3)
{6, 7} undirected simple Int64 graph

julia> ladder_graph(Int8(4))
{8, 10} undirected simple Int8 graph
lollipop_graph(n1, n2)

Create a lollipop graph consisting of a clique of size n1 connected by an edge to a path of size n2.

Implementation Notes

Preserves the eltype of n1 and n2. Will error if the required number of vertices exceeds the eltype. n1 and n2 must be at least 1 so that both the clique and the path have at least one vertex. The graph is organized with nodes 1:n1 being the clique and n1+1:n1+n2 being the path. The clique is connected to the path by an edge (n1, n1+1).

Examples

julia> lollipop_graph(2, 5)
{7, 6} undirected simple Int64 graph

julia> lollipop_graph(Int8(3), Int8(4))
{7, 7} undirected simple Int8 graph
path_digraph(n)

Creates a directed path graph with n vertices.

Examples

julia> path_digraph(5)
{5, 4} directed simple Int64 graph

julia> path_digraph(Int8(10))
{10, 9} directed simple Int8 graph
path_graph(n)

Create an undirected path graph with n vertices.

Examples

julia> path_graph(5)
{5, 4} undirected simple Int64 graph

julia> path_graph(Int8(10))
{10, 9} undirected simple Int8 graph
roach_graph(k)

Create a Roach graph of size k.

References

  • Guattery and Miller 1998

Examples

julia> roach_graph(10)
{40, 48} undirected simple Int64 graph
star_digraph(n)

Create a directed star graph with n vertices.

Examples

julia> star_digraph(3)
{3, 2} directed simple Int64 graph

julia> star_digraph(Int8(10))
{10, 9} directed simple Int8 graph
star_graph(n)

Create an undirected star graph with n vertices.

Examples

julia> star_graph(3)
{3, 2} undirected simple Int64 graph

julia> star_graph(Int8(10))
{10, 9} undirected simple Int8 graph
turan_graph(n, r)

Creates a Turán Graph, a complete multipartite graph with n vertices and r partitions.

Examples

julia> turan_graph(6, 2)
{6, 9} undirected simple Int64 graph

julia> turan_graph(Int8(7), 2)
{7, 12} undirected simple Int8 graph
wheel_digraph(n)

Create a directed wheel graph with n vertices.

Examples

julia> wheel_digraph(5)
{5, 8} directed simple Int64 graph

julia> wheel_digraph(Int8(6))
{6, 10} directed simple Int8 graph
wheel_graph(n)

Create an undirected wheel graph with n vertices.

Examples

julia> wheel_graph(5)
{5, 8} undirected simple Int64 graph

julia> wheel_graph(Int8(6))
{6, 10} undirected simple Int8 graph
smallgraph(s)
smallgraph(s)

Create a small graph of type s. Admissible values for s are:

s graph type

:bull

A bull graph.

:chvatal

A Chvátal graph.

:cubical

A Platonic cubical graph.

:desargues

A Desarguesgraph.

:diamond

A diamond graph.

:dodecahedral

A Platonic dodecahedral graph.

:frucht

A Frucht graph.

:heawood

A Heawood graph.

:house

A graph mimicing the classic outline of a house.

:housex

A house graph, with two edges crossing the bottom square.

:icosahedral

A Platonic icosahedral graph.

:karate

A social network graph called Zachary’s karate club.

:krackhardtkite

A Krackhardt-Kite social network graph.

:moebiuskantor

A Möbius-Kantor graph.

:octahedral

A Platonic octahedral graph.

:pappus

A Pappus graph.

:petersen

A Petersen graph.

:sedgewickmaze

A simple maze graph used in Sedgewick’s Algorithms in C++: Graph Algorithms (3rd ed.)

:tetrahedral

A Platonic tetrahedral graph.

:truncatedcube

A skeleton of the truncated cube graph.

:truncatedtetrahedron

A skeleton of the truncated tetrahedron graph.

:truncatedtetrahedron_dir

A skeleton of the truncated tetrahedron digraph.

:tutte

A Tutte graph.

 
euclidean_graph(N, d; seed=-1, L=1., p=2., cutoff=-1., bc=:open)

Generate N uniformly distributed points in the box ^{d}] and return a Euclidean graph, a map containing the distance on each edge and a matrix with the points' positions.

Examples

julia> g, dists = euclidean_graph(5, 2, cutoff=0.3);

julia> g
{5, 4} undirected simple Int64 graph

julia> dists
Dict{LightGraphs.SimpleGraphs.SimpleEdge{Int64},Float64} with 4 entries:
  Edge 1 => 5 => 0.205756
  Edge 2 => 5 => 0.271359
  Edge 2 => 4 => 0.247703
  Edge 4 => 5 => 0.168372
euclidean_graph(points)

Given the d×N matrix points build an Euclidean graph of N vertices and return a graph and Dict containing the distance on each edge.

Optional Arguments

  • L=1: used to bound the d dimensional box from which points are selected.

  • p=2

  • bc=:open

Implementation Notes

Defining the d-dimensional vectors x[i] = points[:,i], an edge between vertices i and j is inserted if norm(x[i]-x[j], p) < cutoff. In case of negative cutoff instead every edge is inserted. For p=2 we have the standard Euclidean distance. Set bc=:periodic to impose periodic boundary conditions in the box ^d].

Examples

julia> pts = rand(3, 10); # 10 vertices in R^3

julia> g, dists = euclidean_graph(pts, p=1, bc=:periodic) # Taxicab-distance (L^1);

julia> g
{10, 45} undirected simple Int64 graph