Basic Interface

nv(g)

The number of vertices in g.

ne(g)

The number of edges in g.

Time Complexity: O(1)

add_vertex!(g)

Add a new vertex to the graph g.

add_vertices!(g, n)

Add n new vertices to the graph g. Returns the final number of vertices.

rem_vertex!(g, v)

Remove the vertex v from graph g. It will change the label of the last vertex of the old graph to v.

See also rem_vertices!.

pop_vertex!(g)

Remove the last vertex of g. Equivalent to rem_vertex!(g, nv(g)).

rem_vertices!(g, vs)
rem_vertices!(g, v1, v2, ....)

Remove the vertices in vs from graph g.

Some vertices of g may be reindexed during the removal. To keep track of the reindexing, a vertex map is returned, associating vertices with changed indexes to their old indexes.

has_edge(g, e)
has_edge(g, u, v)

Returns true if the graph g has an edge e (from u to v).

src(e)

Returns the source of an edge.

dst(e)

Returns the destination of an edge.

edge(g, u, v)

Returns an edge from 'u' to 'v'. The edge doesn't necessarily exists in g.

add_edge!(g, e) -> (ok, new_edge)

Add to g the edge e.

add_edge!(g, u, v) -> (ok, new_edge)

Add to g an edge from u to v.

ok=false if add fails (e.g. if vertices are not in the graph or the edge is already present) and true otherwise. new_edge is the descriptor of the new edge.

unsafe_add_edge!(g, u, v)

Possibly faster and unsafer version of add_edge!, which doesn't guarantee some graph invariant properties.

For example, some graph types (e.g. Graph) assume sorted adjacency lists as members. In this case order is not preserved while inserting new edges, resulting in a faster construction of the graph. As a consequence though, some functions such has_edge(g, u, v) could give incorrect results.

To restore the correct behaviour, call rebuild!(g) after the last call to unsafe_add_edge!.

rebuild!(g)

Check and restore the structure of g, which could be corrupted by the use of unsafe functions (e. g. unsafe_add_edge!)

rem_edge!(g, e)

Remove the edge e.

rem_edge!(g, u, v)

Remove the edge from u to v.

Returns false if edge removal fails (e.g., if the edge does not exist) and true otherwise.

degree(g, v)

Return the number of edges from the vertex v.

in_degree(g, v)

Returns the number of edges which start at vertex v.

out_degree(g, v)

Returns the number of edges which end at vertex v.

neighbors(g, v)

Returns a list of all neighbors from vertex v in g.

For directed graph, this is equivalent to out_neighbors(g, v).

NOTE: it may return a reference, not a copy. Do not modify result.

in_neighbors(g, v)

Returns an iterable to all neighbors connected to vertex v by an incoming edge.

NOTE: it may return a reference, not a copy. Do not modify result.

out_neighbors(g::AGraphOrDiGraph, v)

Returns an iterable to all neighbors connected to vertex v by an outgoing edge.

NOTE: it may return a reference, not a copy. Do not modify result.

all_neighbors(g, v)

Iterates over all distinct in/out neighbors of vertex v in g.

edges(g, v)

Returns an iterator to the edges in g coming from vertex v. v == src(e) for each returned edge e.

It is equivalent to out_edges.

For digraphs, use all_edges to iterate over both in and out edges.

in_edges(g, v)

Returns an iterator to the edges in g going to vertex v. v == dst(e) for each returned edge e.

out_edges(g, v)

Returns an iterator to the edges in g coming from vertex v. v == src(e) for each returned edge e.

all_edges(g, v)

Iterates over all in and out edges of vertex v in g.

swap_vertices!(g, u, v)

Swap the labels of vertices u and v. In the new graph all old neighbors of vertex u will be neighbors of v and viceversa.

has_vertex(g, v)

Return true if v is a vertex of g.

is_directed(g)

Check if g a graph with directed edges.

reverse(e)

Returns an edge with swapped src(e) and dst(e).

reverse(g::ADiGraph)

Produces a graph where all edges are reversed from the original.

reverse!(g::DiGraph)

In-place reverse (modifies the original graph).

adjacency_list(g::AGraph)
adjacency_list(g::ADiGraph, dir=:out)

Returns the adjacency list a of a graph (a vector of vector of ints). The i-th element of the adjacency list is a vector containing the neighbors of i in g.

For directed graphs a second optional argument can be specified (:out or :in). The neighbors in the returned adjacency list are considered accordingly as those related through outgoing or incoming edges.

The elements of a[i] have the same order as in the iterator (out_/in_)neighbors(g,i).

Attention: For some graph types it returns a reference, not a copy, therefore the returned object should not be modified.

clean_vertex!(g, v)

Remove all incident edges on vertex v in g.

density(g)

Density is defined as the ratio of the number of actual edges to the number of possible edges. This is $|v| |v-1|$ for directed graphs and $(|v| |v-1|) / 2$ for undirected graphs.

vertices(g)

Returns an iterator to the vertices of a graph (i.e. 1:nv(g))

has_self_loops(g)

Returns true if g has any self loops.

num_self_loops(g)

Returns the number of self loops in g.

is_graphical(degs::Vector{Int})

Check whether the degree sequence degs is graphical, according to Erdös-Gallai condition.

Time complexity: O(length(degs)^2)

graph{G<:AGraph}(n, edgelist::Vector{Tuple{Int,Int}},
    G = Graph)

Build a graph with n vertices, of type G, and given edgelist.

graph(s::Symbol, G = Graph)

Creates a notorious graph s of type G. Admissible values for s are:

A collection of real world graphs is available through the readgraph function.

digraph{G<:AGraph}(n, edgelist::Vector{Tuple{Int,Int}},
    G = Graph)

Build a digraph with n vertices, type G, and given edgelist.

digraph(s::Symbol, G = DiGraph)

Creates a notorious digraph s of type G. Admissible values for s are:

edgetype(g)
edgetype(G)

Returns the type of edges of graph g (or graph type G), i. e. the element type returned of the iterator edges(g).

vertextype(g)
vertextype(G)

Returns the integer type of vertices of graph g (or graph type G).

graphtype{G<:AGraphOrDiGraph}(::Type{G})

The graph type corresponding to G. If G<:AGraph returns G, if G<:ADiGraph returns a type H<:AGraph.

digraphtype{G<:AGraphOrDiGraph}(::Type{G})

The digraph type corresponding to G. If G<:ADiGraph returns G, if G<:AGraph returns a type H<:ADiGraph.