Update docstrings, minor fixes

Co-Authored-By: Pietro Monticone <[email protected]>
Co-Authored-By: Claudio Moroni <[email protected]>

Author: 3 people

docs/src/API.md

@@ -43,7 +43,7 @@ nodes(::AbstractSubGraph)
 has_vertex(layer::L, v::MultilayerVertex) where { T,U,G, L <: Layer{T,U,G}}
 has_vertex(interlayer::In, v::MultilayerVertex) where { T,U,G, In <: Interlayer{T,U,G}}
 nv(subgraph::S) where { S <: AbstractSubGraph}
-mv_vertices(subgraph::S) where {S <: AbstractSubGraph{ <: Integer, <: AbstractSimpleGraph}}
+mv_vertices(subgraph::S) where {S<:AbstractSubGraph}
 ```
 
 ### Multilayer-specific methods
@@ -84,15 +84,15 @@ AbstractMultilayerVertex
 
 ```@docs
 AbstractMultilayerEdge
-metadata(he::HalfEdge)
-weight(he::HalfEdge)
+metadata(he::MultilayerGraphs.HalfEdge)
+weight(he::MultilayerGraphs.HalfEdge)
 ```
 
 # Subgraphs
 
 ```@docs
 has_vertex(subgraph::S, v::T ) where {T,U,G,S<:AbstractSubGraph{T,U,G}}
-vertices(subgraph::S) where {S <: AbstractSubGraph{ <: Integer, <: AbstractSimpleGraph}}
+vertices(subgraph::S) where {S <: AbstractSubGraph{ <: Integer, <: AbstractGraph}}
 inneighbors(subgraph::S, v::T) where {T,U,G, S <: AbstractSubGraph{T,U,G}}
 inneighbors(subgraph::S, mv::MultilayerVertex)  where {T,U,G, S <: AbstractSubGraph{T,U,G}}
 ```
@@ -107,7 +107,7 @@ inneighbors(subgraph::S, mv::MultilayerVertex)  where {T,U,G, S <: AbstractSubGr
 has_vertex(mg::M, v::T) where {T,U, M <: AbstractMultilayerGraph{T,U}}
 vertices(mg::M) where {M<:AbstractMultilayerGraph}
 inneighbors(mg::M, v::T) where {M <: AbstractMultilayerUGraph{T} } where { T <: Integer}
-inneighbors(mg::M, v::T) where {M <: AbstractMultilayerDirDiGraph{T} } where { T <: Integer}
+inneighbors(mg::M, v::T) where {M <: AbstractMultilayerDiGraph{T} } where { T <: Integer}
 inneighbors( mg::M, mv::V ) where {T,M<:AbstractMultilayerGraph{T,<:Real},V<:MultilayerVertex}
 ```
 

src/MultilayerGraphs.jl

@@ -46,6 +46,7 @@ export
     # layerdescriptor.jl
     # interlayerdescriptor.jl
     # abstractsubgraph.jl
+    AbstractSubGraph,
     nodes,
     eltype,
     has_vertex,
@@ -132,6 +133,7 @@ export
     specify_interlayer!,
     von_neumann_entropy,
     # abstractmultilayerdigraph.jl
+    AbstractMultilayerDiGraph,
     # multilayergraph.jl
     MultilayerGraph,
     fadjlist,
@@ -153,7 +155,6 @@ using Distributions: Uniform
 using LinearAlgebra, Statistics, OMEinsum, TensorOperations, Distributions
 using DataStructures, SparseArrays
 using Graphs, SimpleWeightedGraphs, MetaGraphs, SimpleValueGraphs
-using Agents
 
 
 

src/abstractmultilayergraph.jl

@@ -37,7 +37,7 @@ abstract type AbstractMultilayerGraph{T<:Integer,U<:Real} <: AbstractGraph{T} en
 
 Return the nodes of the AbstractMultilayerGraph `mg`, in order of addition.
 """
-nodes(mg::M) where {M<:AbstractMultilayerGraph} = [couple[2] for couple in sort(collect(mg.idx_N_associations), by = first)]
+nodes(mg::AbstractMultilayerGraph) = [couple[2] for couple in sort(collect(mg.idx_N_associations), by = first)]
 
 """
     nn(mg::M) where {M <: AbstractMultilayerGraph }
@@ -95,19 +95,19 @@ end
 
 # Vertices
 """
-    Base.eltype(mg::M) where {M <: AbstractMultilayerGraph}
+    eltype(::M) where {T,M<:AbstractMultilayerGraph{T}}
 
 Return the vertex type of `mg`.
 """
-Base.eltype(::M) where {T,U,M<:AbstractMultilayerGraph{T,U}} = T
+Base.eltype(::M) where {T,M<:AbstractMultilayerGraph{T}} = T
 
 
 """
-    has_vertex(mg::M, v::T) where {T,U, M <: AbstractMultilayerGraph{T,U}}
+    has_vertex(mg::M, v::T) where {T,M <: AbstractMultilayerGraph{T}}
 
 Return true if `v` is in mg, else false.
 """
-Graphs.has_vertex(mg::M, v::T ) where {T,U, M <: AbstractMultilayerGraph{T,U}} = v in domain(mg.v_V_associations) # && !(mg.v_V_associations[v] isa MissingVertex)
+Graphs.has_vertex(mg::M, v::T ) where {T, M <: AbstractMultilayerGraph{T}} = v in domain(mg.v_V_associations) # && !(mg.v_V_associations[v] isa MissingVertex)
 
 """
     has_vertex(mg::M, mv::MultilayerVertex) where {T,U, M <: AbstractMultilayerGraph{T,U}}
@@ -128,14 +128,7 @@ mv_vertices(mg::AbstractMultilayerGraph)  =  [get_rich_mv(mg, v) for v in vertic
 
 Return the number of vertices in `mg`, excluding the missing vertices.
 """
-Graphs.nv(mg::M) where {M<:AbstractMultilayerGraph} = length(mg.v_V_associations) #length([mv for mv in image(mg.v_V_associations) if !(mv isa MissingVertex)])
-
-#= """
-    nv_withmissing(mg::M) where {M<:AbstractMultilayerGraph}
-
-Return the number of vertices of `mg`, including the missing vertices.
-"""
-nv_withmissing(mg::M) where {M<:AbstractMultilayerGraph} = length(mg.v_V_associations) =#
+Graphs.nv(mg::AbstractMultilayerGraph) = length(mg.v_V_associations)
 
 """
     vertices(mg::M) where {M<:AbstractMultilayerGraph}

src/node.jl

@@ -1,5 +1,5 @@
 """
-    abstract type AbstractNode end
+    abstract type AbstractNode
 
 An abstract type representing a node.
 """

src/subgraphs/abstractsubgraph.jl

@@ -1,62 +1,67 @@
+"""
+    abstract type AbstractSubGraph{T <: Integer,U <: Real,G <: AbstractGraph{T}}
+
+An abstract type representing a subgraph (i.e. a layer or an interlayer).
+"""
 abstract type AbstractSubGraph{T <: Integer,U <: Real,G <: AbstractGraph{T}} end
 
 # Nodes
 """
-    nodes(subgraph::S) where { S <: AbstractSubGraph}
+    nodes(subgraph::AbstractSubGraph)
 
 Return the collection of the nodes of `subgraph`.
 """
-nodes(subgraph::S) where {S<:AbstractSubGraph} = unique([mv.node for mv in mv_vertices(subgraph)])
+nodes(subgraph::AbstractSubGraph) = unique([mv.node for mv in mv_vertices(subgraph)])
 
 # Vertices
 """
-    Base.eltype(subgraph::S) where { S <: AbstractSubGraph}
+    Base.eltype(subgraph::AbstractSubGraph)
 
 Return the vertex type of `subgraph`.
 """
-Base.eltype(subgraph::S) where {S<:AbstractSubGraph} = typeof(subgraph).parameters[1] 
+Base.eltype(subgraph::AbstractSubGraph) = typeof(subgraph).parameters[1] 
 
 """
-    has_vertex(subgraph::S, v::T ) where {T,U,G,S<:AbstractSubGraph{T,U,G}}
+    has_vertex( subgraph::S, v::T ) where {T,S<:AbstractSubGraph{T}}
 
 Return `true` if `v` is a vertex of `subgraph`.
 """
-Graphs.has_vertex( subgraph::S, v::T ) where {T,U,G,S<:AbstractSubGraph{T,U,G}} =  has_vertex(subgraph.graph, v)
+Graphs.has_vertex(subgraph::S, v::T) where {T,S<:AbstractSubGraph{T}} =  has_vertex(subgraph.graph, v)
 
 """
-    nv(subgraph::S) where { S <: AbstractSubGraph}
+    nv(subgraph::AbstractSubGraph)
 
 Return the number of vertices in `subgraph`.
 """
-Graphs.nv(subgraph::S) where {S<:AbstractSubGraph} = nv(subgraph.graph) #length(vertices(subgraph))
+Graphs.nv(subgraph::AbstractSubGraph) = nv(subgraph.graph) #length(vertices(subgraph))
 
 """
-    vertices(subgraph::S) where {S <: AbstractSubGraph{ <: Integer, <: AbstractSimpleGraph}}
+    vertices(subgraph::AbstractSubGraph)
 
 Return the collection of the vertices of `subgraph`.
 """
-Graphs.vertices(subgraph::S) where {S<:AbstractSubGraph} = vertices(subgraph.graph)
+Graphs.vertices(subgraph::AbstractSubGraph) = vertices(subgraph.graph)
 
 """
-    mv_vertices(subgraph::S) where {S <: AbstractSubGraph{ <: Integer, <: AbstractSimpleGraph}}
+    mv_vertices(subgraph::AbstractSubGraph)
 
 Return the collection of the `MultilayerVertex`s of `subgraph`.
 """
-mv_vertices(subgraph::S) where {S<:AbstractSubGraph} = get_rich_mv.(Ref(subgraph), vertices(subgraph)) 
+mv_vertices(subgraph::AbstractSubGraph) = get_rich_mv.(Ref(subgraph), vertices(subgraph))
 
 """
-    inneighbors(subgraph::S, v::T) where {T,U,G, S <: AbstractSubGraph{T,U,G}} 
+    inneighbors(subgraph::S, v::T) where {T, S <: AbstractSubGraph{T}} 
 
 Return the list of inneighbors of `v` within `subgraph`.
 """
-Graphs.inneighbors(subgraph::S, v::T) where {T,U,G,S<:AbstractSubGraph{T,U,G}} = inneighbors(subgraph.graph, v)
+Graphs.inneighbors(subgraph::S, v::T) where {T,S<:AbstractSubGraph{T}} = inneighbors(subgraph.graph, v)
 
 """
-    inneighbors(subgraph::S, mv::MultilayerVertex)  where {T,U,G, S <: AbstractSubGraph{T,U,G}} 
+    inneighbors(subgraph::AbstractSubGraph, mv::MultilayerVertex)
 
 Return the list of inneighbors of `mv` within `subgraph`.
 """
-Graphs.inneighbors(subgraph::S, mv::MultilayerVertex) where {T,U,G,S<:AbstractSubGraph{T,U,G}} = inneighbors(subgraph, get_v(subgraph,mv))
+Graphs.inneighbors(subgraph::AbstractSubGraph, mv::MultilayerVertex) = inneighbors(subgraph, get_v(subgraph,mv))
 
 """
     mv_inneighbors(subgraph::AbstractSubGraph, mv::MultilayerVertex) 
@@ -66,18 +71,18 @@ Return the `MultilayerVertex`s inneighbors of `mv` within `subgraph`.
 mv_inneighbors(subgraph::AbstractSubGraph, mv::MultilayerVertex) = get_rich_mv.(Ref(subgraph), inneighbors(subgraph,mv))
 
 """
-    outneighbors(subgraph::S, v::T) where {T,U,G, S <: AbstractSubGraph{T,U,G}} 
+    outneighbors(subgraph::S, v::T) where {T,S<:AbstractSubGraph{T}} 
 
 Return the list of outneighbors of `v` within `subgraph`.
 """
-Graphs.outneighbors(subgraph::S, v::T) where {T,U,G,S<:AbstractSubGraph{T,U,G}} = outneighbors(subgraph.graph, v)
+Graphs.outneighbors(subgraph::S, v::T) where {T,S<:AbstractSubGraph{T}} = outneighbors(subgraph.graph, v)
 
 """
-    outneighbors(subgraph::S, mv::MultilayerVertex)  where {T,U,G, S <: AbstractSubGraph{T,U,G}} 
-
+    outneighbors(subgraph::AbstractSubGraph, mv::MultilayerVertex)
+ 
 Return the list of outneighbors of `mv` within `subgraph`.
 """
-Graphs.outneighbors(subgraph::S, mv::MultilayerVertex) where {T,U,G,S<:AbstractSubGraph{T,U,G}} = outneighbors(subgraph, subgraph.v_V_associations(get_bare_mv(mv)))
+Graphs.outneighbors(subgraph::AbstractSubGraph, mv::MultilayerVertex) = outneighbors(subgraph, subgraph.v_V_associations(get_bare_mv(mv)))
 
 """
     mv_outneighbors(subgraph::AbstractSubGraph, mv::MultilayerVertex)

src/subgraphs/interlayer.jl

@@ -413,11 +413,11 @@ function is_multiplex_interlayer(interlayer::In) where {In<:Interlayer}
 end
 
 """
-    has_vertex(interlayer::In, v::MultilayerVertex) where { T,U,G, In <: Interlayer{T,U,G}}
+    has_vertex(interlayer::Interlayer, v::MultilayerVertex)
 
 Return `true` if `v` is a vertex of `interlayer`.
 """
-has_node( interlayer::In, n::Node ) where {T,U,G,In<:Interlayer{T,U,G}}  =  n in nodes(interlayer.layer_1) || n in nodes(interlayer.layer_2) 
+has_node( interlayer::Interlayer, n::Node ) =  n in nodes(interlayer.layer_1) || n in nodes(interlayer.layer_2) 
 
 
 """

src/subgraphs/layer.jl

@@ -162,11 +162,11 @@ has_node(layer::L, n::Node) where {L<:Layer} = MV(n, layer.name) ∈ image(layer
 
 
 """
-    has_vertex(layer::L, v::MultilayerVertex) where { T,U,G, L <: Layer{T,U,G}}
+    has_vertex(layer::Layer, v::MultilayerVertex)
 
 Return `true` if `v` is a vertex of `layer`.
 """
-Graphs.has_vertex(layer::L, mv::MultilayerVertex) where {T,U,G,L<:Layer{T,U,G}} = MV(node(mv), name(layer)) ∈ collect(image(layer.v_V_associations))
+Graphs.has_vertex(layer::Layer, mv::MultilayerVertex) = MV(node(mv), name(layer)) ∈ collect(image(layer.v_V_associations))
 
 # TODO:
 # Implement a MultilayerVertex constructor that leaves the .layer field unspecified, for ease of use of the following function

src/utilities.jl

@@ -574,7 +574,7 @@ Returns a simple graph with a given finite degree sequence of non-negative integ
 2. [Kleitman and Wang (1973)](https://doi.org/10.1016/0012-365X(73)90037-X)
 """
 function havel_hakimi_(empty_graph::SimpleGraph, degree_sequence::Vector{<:Integer}) # Please think about a decent name!
-    # Check wether the given degree sequence contains only non-negative integers
+    # Check whether the given degree sequence contains only non-negative integers
     !any(degree -> degree < 0, degree_sequence) || throw(ArgumentError("The degree sequence (degree_sequence) is invalid: it must contain non-negative integers only."))
     # Check whether the given degree sequence is compatible with the given multilayer graph 
     nv(empty_graph) == length(degree_sequence) || throw(ArgumentError("The degree sequence (degree_sequence) and the multilayer graph (empty_mg) are incompatible: the length of the degree sequence doesn't coincide with the number of vertices.")) 

src/vertices/multilayervertex.jl

@@ -1,5 +1,5 @@
 """
-    AbstractMultilayerVertex{S}
+    AbstractMultilayerVertex{S} <: AbstractVertex
 
 An abstract type representing an abstract MultilayerGraph vertex.
 """