Reference

LeftorRight

LeftorRight = Union{Left, Right}

AbstractIndexedDiGraph{T} <: AbstractIndexedGraph{T}

Abstract type for representing directed graphs.

AbstractIndexedEdge{T<:Integer} <: AbstractEdge{T}

Abstract type for indexed edge. AbstractIndexedEdge{T}s must have the following elements:

• idx::T integer positive index

AbstractIndexedGraph{T} <: AbstractGraph{T}

An abstract type representing an indexed graph. AbstractIndexedGraphs must have the following elements:

• A::SparseMatrixCSC adjacency matrix

BipartiteGraphVertex

A BipartiteGraphVertex{LR<:LeftorRight,T<:Integer} represents a vertex in a bipartite graph.

PARAMETERS

• LR – Either Left or Right

FIELDS

• i – The index of the vertex within its block.

BipartiteIndexedGraph(g::AbstractGraph)

Build a BipartiteIndexedGraph from any undirected, bipartite graph.

BipartiteIndexedGraph(A::AbstractMatrix)

Construct a BipartiteIndexedGraph from adjacency matrix A with the convention that rows are vertices belonging to the left block, columns to the right block

BipartiteIndexedGraph{T<:Integer} <: AbstractIndexedGraph{T}

A type representing a sparse, undirected bipartite graph.

FIELDS

• A – adjacency matrix filled with NullNumbers. Rows are vertices belonging to the left block, columns to the right block
• X – square matrix for efficient access by row. X[j,i] points to the index of element A[i,j] in A.nzval.

IndexedBiDiGraph(A::AbstractMatrix)

Construct an IndexedBiDiGraph from the adjacency matrix A.

IndexedBiDiGraph internally stores the transpose of A. To avoid overhead due to the transposition, use IndexedBiDiGraph(transpose(At)) where At is the transpose of A.

IndexedBiDiGraph(A::AbstractSimpleGraph)

Construct an IndexedBiDiGraph from any AbstractSimpleGraph (Graphs.jl), directed or otherwise.

IndexedBiDiGraph{T<:Integer} <: AbstractIndexedDiGraph{T}

A type representing a sparse directed graph with access to both outedges and inedges.

FIELDS

• A – square matrix filled with NullNumbers. A[i,j] corresponds to edge j=>i.
• X – square matrix for efficient access by row. X[j,i] points to the index of element A[i,j] in A.nzval.

IndexedDiGraph(A::AbstractMatrix)

Constructs a IndexedDiGraph from the adjacency matrix A.

IndexedDiGraph internally stores the transpose of A. To avoid overhead due to the transposition, use IndexedDiGraph(transpose(At)) where At is the transpose of A.

IndexedDiGraph(A::AbstractSimpleGraph)

Construct an IndexedDiGraph from any AbstractSimpleGraph (Graphs.jl), directed or otherwise.

IndexedDiGraph{T<:Integer} <: AbstractIndexedDiGraph{T}

A type representing a sparse directed graph with access only to outedges.

FIELDS

• A – square matrix filled with NullNumbers. A[i,j] corresponds to an edge j=>i

IndexedEdge{T<:Integer} <: AbstractIndexedEdge{T}

Edge type for IndexedGraphs. Edge indices can be used to access edge properties stored in separate containers.

IndexedGraph(A::AbstractMatrix)

Construct an IndexedGraph from symmetric adjacency matrix A.

IndexedGraph(A::SimpleGraph)

Construct an IndexedGraph from undirected SimpleGraph (Graphs.jl).

IndexedGraph{T<:Integer} <: AbstractIndexedGraph{T}

A type representing a sparse undirected graph.

FIELDS

• A – square adjacency matrix. A[i,j] == A[j,i] contains the unique index associated to unidrected edge (i,j)

Left

Singleton type used to represent a vertex belonging to the left block in a BipartiteGraphVertex

Right

Singleton type used to represent a vertex belonging to the Right block in a BipartiteGraphVertex

adjacency_matrix(g::BipartiteIndexedGraph, T::DataType=Int)

Return the symmetric adjacency matrix of size nv(g) = nv_left(g) + nv_right(g) where no distinction is made between left and right nodes.

degree(g::BipartiteIndexedGraph, v::BipartiteGraphVertex)

Return the degree of variable v specified by a BipartiteGraphVertex.

edges(g::IndexedGraph, i::Integer)

Return a lazy iterators to the edges incident to i.

By default unordered edges sort source and destination nodes in increasing order. See outedges and inedges if you need otherwise.

inneighbors(g::BipartiteIndexedGraph, v::BipartiteGraphVertex{<:LeftorRight})

Return a lazy iterator to the neighbors of variable v specified by a BipartiteGraphVertex.

inneighbors(g::BipartiteIndexedGraph, i::Integer)

Return a lazy iterator to the neighbors of variable i specified by its linear index.

outneighbors(g::BipartiteIndexedGraph, v::BipartiteGraphVertex{<:LeftorRight})

Return a lazy iterator to the neighbors of variable v specified by a BipartiteGraphVertex.

outneighbors(g::BipartiteIndexedGraph, i::Integer)

Return a lazy iterator to the neighbors of variable i specified by its linear index.

bidirected_with_mappings(g::IndexedGraph) -> (gdir, dir2undir, undir2dir)

Construct an IndexedBiDiGraph gdir from an IndexedGraph g by building two directed edges per every undirected edge in g. In addition, return two vectors containing mappings from the undirected edges of g to the corresponding directed edges of gdir.

OUTPUT

• gdir – The directed graph
• dir2undir – A vector of integers mapping the indices of the directed edges of gdir to the corresponding undirected edges of g
• undir2dir – A vector of vectors with two integers each mapping the indices of the undirected edges of g to the two corresponding directed edges of gdir

get_edge(g::AbstractIndexedDiGraph, src::Integer, dst::Integer)
get_edge(g::AbstractIndexedDiGraph, id::Integer)

Get edge given source and destination or given edge index.

get_edge(g::IndexedGraph, src::Integer, dst::Integer)
get_edge(g::IndexedGraph, id::Integer)

Get edge given source and destination or given edge index.

inedges(g::BipartiteIndexedGraph, v::BipartiteGraphVertex{<:LeftorRight})

Return a lazy iterator to the edges incident on a variable v specified by a BipartiteGraphVertex, with v as the destination.

inedges(g::BipartiteIndexedGraph, i::Integer)

Return a lazy iterator to the edges incident on a variable i specified by its linear index, with i as the destination.

inedges(g::AbstractIndexedBiDiGraph, i::Integer)

Return a lazy iterator to the edges ingoing to node i in g.

inedges(g::IndexedGraph, i::Integer)

Return a lazy iterators to the edges incident to i with i as the destination.

linearindex(g::BipartiteIndexedGraph, v::BipartiteGraphVertex{LR}) where {LR<:LeftorRight}
linearindex(g::BipartiteIndexedGraph, i::Integer, ::Type{LR}) where LR<:LeftorRight

Return the linear index of a vertex, specified either by a BipartiteGraphVertex or by its index and block.

nv_left(g::BipartiteIndexedGraph)

Return the number of vertices in the left block

nv_right(g::BipartiteIndexedGraph)

Return the number of vertices in the right block

outedges(g::AbstractIndexedDiGraph, i::Integer)

Return a lazy iterator to the edges outgoing from node i in g.

outedges(g::BipartiteIndexedGraph, v::BipartiteGraphVertex{<:LeftorRight})

Return a lazy iterator to the edges incident on a variable v specified by a BipartiteGraphVertex, with v as the source.

outedges(g::BipartiteIndexedGraph, i::Integer)

Return a lazy iterator to the edges incident on a variable i specified by its linear index, with i as the source.

outedges(g::IndexedGraph, i::Integer)

Return a lazy iterators to the edges incident to i with i as the source.

rand_bipartite_graph([rng=default_rng()], nleft, nright, ned)

Create a bipartite graph with nleft nodes in the left block, nright nodes in the right block and ned edges taken uniformly at random.

rand_bipartite_graph([rng=default_rng()], nleft, nright, p)

Create a bipartite graph with nleft nodes in the left block, nright nodes in the right block and edges taken independently with probability p.

rand_bipartite_tree([rng=default_rng()], n)

Create a tree bipartite graph with n vertices in total. The proportion of left/right nodes is random.

rand_regular_bipartite_graph([rng=default_rng()], nleft, nright, k)

Create a bipartite graph with nleft nodes in the left block, nright nodes in the right block, where all left nodes have degree k.

vertex(g::BipartiteIndexedGraph, i::Integer)

Build the BipartiteGraphVertex corresponding to linear index i. Throws an error if i is not in the range of vertices of g

vertex(i::Integer, ::Type{<:LeftorRight})

Build a BipartiteGraphVertex

vertex_left(g::BipartiteIndexedGraph, e::IndexedEdge)

Return the (in-block) index of the left-block vertex in e.

vertex_right(g::BipartiteIndexedGraph, e::IndexedEdge)

Return the (in-block) index of the right-block vertex in e.

vertices_left(g::BipartiteIndexedGraph)

Return a lazy iterator to the vertices in the left block

vertices_right(g::BipartiteIndexedGraph)

Return a lazy iterator to the vertices in the right block

issymmetric(g::IndexedBiDiGraph) -> Bool

Test whether a directed graph is symmetric, i.e. for each directed edge i=>j there also exists the edge j=>i