Merge branch 'main' of https://github.com/JuliaGraphs/MultilayerGraphs.jl

Author: InterdisciplinaryPhysicsTeam

src/utilities.jl

@@ -99,7 +99,6 @@ The Kronecker delta.
 
 ### CONSTRUCTORS
 
-
     δk{T}(N::Int64) where {T <: Number}
 
 Inner constructor that only requires `N` and the `eltype`.
@@ -109,7 +108,7 @@ mutable struct δk{T} <: AbstractVector{T}
     representation::Matrix{Int64}
 
     # Inner constructor that only requires N and the eltype.
-    
+
     function δk{T}(N::Int64) where {T<:Number}
         out = new{T}(N)
         representation = [out[h, k] for h in 1:N, k in 1:N]
@@ -120,13 +119,13 @@ end
 
 """
     δk(N::Int64)
-    
+
 Outer constructor that only requires `N`.
 """
 δk(N::Int64) = δk{Int64}(N)
 
 """
-    getindex(d::δk{T}, h::Int64, k::Int64) where T 
+    getindex(d::δk{T}, h::Int64, k::Int64) where T
 
 `getindex` dispatch that allows to easily construct the `representation` field of `δ_Ω` inside its inner constructor.
 """
@@ -273,7 +272,7 @@ Base.size(d::δ_Ω{T}) where {T} = (d.N >= 3 ? 3 : d.N, d.N, d.N, d.N)
 """
 function get_diagonal_elements(arr::Array{T,N}) where {T,N}
     output = similar(arr)
-    
+
     for cart_idx in CartesianIndices(arr)
         vertices_indexes = Tuple(cart_idx)[1:2]
         layers_indexes = Tuple(cart_idx)[3:4]
@@ -359,11 +358,6 @@ Check whether `A` is symmetric (within `zero(T)`).
 """
 isapproxsymmetric(A::Matrix{T}) where {T<:Integer} = all(abs.(A .- A') .<= zero(T))
 
-#= """
-"""
-function Graphs.isgraphical(degree_sequence::Vector{<:Integer}; allow_self_loops::Bool)
-end =#
-
 """
     isdigraphical(indegree_sequence::Vector{<:Integer}, outdegree_sequence::Vector{<:Integer} )
 
@@ -382,12 +376,12 @@ function isdigraphical(indegree_sequence::Vector{<:Integer}, outdegree_sequence:
 
     n = length(indegree_sequence)
 
-    n == length(outdegree_sequence) || return false 
+    n == length(outdegree_sequence) || return false
 
     sum(indegree_sequence) == sum(outdegree_sequence) || return false
 
     _sortperm = sortperm(indegree_sequence, rev = true)
-    
+
     sorted_indegree_sequence = indegree_sequence[_sortperm]
     sorted_outdegree_sequence = outdegree_sequence[_sortperm]
 
@@ -409,7 +403,7 @@ function isdigraphical(indegree_sequence::Vector{<:Integer}, outdegree_sequence:
     # Similarly for `outdegree_min_sum`.
 
     @inbounds for r = 1:(n - 1)
-        
+
         indegree_sum += sorted_indegree_sequence[r]
         outdegree_min_sum = sum([min(sorted_outdegree_sequence[i], r-1) for i in 1:r])
         cum_min = sum([min(sorted_outdegree_sequence[i], r) for i in (1+r):n])
@@ -422,9 +416,8 @@ function isdigraphical(indegree_sequence::Vector{<:Integer}, outdegree_sequence:
     return true
 end
 
-
 """
-    _random_undirected_configuration(empty_mg::M, degree_sequence::Vector{ <: Integer}) where {T,U,M <: MultilayerGraph{T,U}}   
+    _random_undirected_configuration(empty_mg::M, degree_sequence::Vector{ <: Integer}) where {T,U,M <: MultilayerGraph{T,U}}
 
 Internal function. Returns a `MultilayerEdge` list compatible with `empty_mg`, using a relatively inefficient algorithm.
 """
@@ -448,8 +441,8 @@ function _random_undirected_configuration(empty_mg::M, degree_sequence::Vector{
                try
                     dsts = nothing
                     if allow_self_loops
-                        dsts = sample(collect(keys(mvs_degree_dict)), mvs_degree_dict[src]; replace = false) # This would be correct  but we have no "isgraphical" function that takes into account self loops. This section of the code is thus disabled. 
-                    else 
+                        dsts = sample(collect(keys(mvs_degree_dict)), mvs_degree_dict[src]; replace = false) # This would be correct  but we have no "isgraphical" function that takes into account self loops. This section of the code is thus disabled.
+                    else
                         dsts = sample(collect(setdiff(keys(mvs_degree_dict), [src])), mvs_degree_dict[src]; replace = false)
                     end
 
@@ -462,7 +455,7 @@ function _random_undirected_configuration(empty_mg::M, degree_sequence::Vector{
                         end
 
                         descriptor = get_subgraph_descriptor(empty_mg, src.layer, dst.layer)
-                        
+
                         push!(edge_list, MultilayerEdge(src, dst, descriptor.default_edge_weight(src,dst), descriptor.default_edge_metadata(src,dst)))
                     end
 
@@ -476,7 +469,7 @@ function _random_undirected_configuration(empty_mg::M, degree_sequence::Vector{
                 end
             else
                 continue
-            end 
+            end
         end
         success = length(mvs_degree_dict) == 0
     end
@@ -502,34 +495,34 @@ function _random_directed_configuration(empty_mg::M, indegree_sequence::Vector{
         @info "Looping through wirings to find one that works..."
         # Loop until a successful wiring is found
         while !success
-    
+
             mvs_indegree_dict = Dict(mv => indeg for (mv,indeg) in zip(mvs,indegree_sequence) if indeg != 0)
             mvs_outdegree_dict = Dict(mv => outdeg for (mv,outdeg) in zip(mvs,outdegree_sequence) if outdeg != 0)
             edge_list = MultilayerEdge[]
             for src in mvs
-    
+
                 if src in keys(mvs_outdegree_dict)
                    try
                         dsts = nothing
                         if allow_self_loops
-                            dsts = sample(collect(keys(mvs_indegree_dict)), mvs_outdegree_dict[src]; replace = false) # This would be correct  but we have no "isgraphical" function that takes into account self loops. This section of the code is thus disabled. 
-                        else 
+                            dsts = sample(collect(keys(mvs_indegree_dict)), mvs_outdegree_dict[src]; replace = false) # This would be correct  but we have no "isgraphical" function that takes into account self loops. This section of the code is thus disabled.
+                        else
                             dsts = sample(collect(setdiff(keys(mvs_indegree_dict), [src])), mvs_outdegree_dict[src]; replace = false)
                         end
-    
+
                         for dst in dsts
-    
+
                             mvs_indegree_dict[dst] = mvs_indegree_dict[dst] - 1
-    
+
                             if mvs_indegree_dict[dst] == 0
                                 delete!(mvs_indegree_dict, dst)
                             end
-    
+
                             descriptor = get_subgraph_descriptor(empty_mg, src.layer, dst.layer)
-                            
+
                             push!(edge_list, MultilayerEdge(src, dst, descriptor.default_edge_weight(src,dst), descriptor.default_edge_metadata(src,dst)))
                         end
-    
+
                         delete!(mvs_outdegree_dict, src)
                     catch e
                         if cmp(e.msg,"Cannot draw more samples without replacement.") == 0
@@ -542,17 +535,14 @@ function _random_directed_configuration(empty_mg::M, indegree_sequence::Vector{
                     continue
                 end
             end
-            success = length(mvs_indegree_dict) == 0 && length(mvs_outdegree_dict) == 0 
+            success = length(mvs_indegree_dict) == 0 && length(mvs_outdegree_dict) == 0
         end
-    
-
     return edge_list
-    
 end
 
 
 """
-    cartIndexTovecIndex(cart_index::CartesianIndex, tensor_size::NTuple{N, <: Integer} ) where N   
+    cartIndexTovecIndex(cart_index::CartesianIndex, tensor_size::NTuple{N, <: Integer} ) where N
 
 Internal function. Converts `cart_index` to an integer index such that it corresponds to the same element under flattening of the tensor whose size is `tensor_size`.
 """
@@ -563,9 +553,9 @@ cartIndexTovecIndex(cart_index::Union{NTuple{N, Integer},CartesianIndex}, tensor
     havel_hakimi_(empty_graph::SimpleGraph, degree_sequence::Vector{<:Integer})
 
 Returns a simple graph with a given finite degree sequence of non-negative integers generated via the Havel-Hakimi algorithm which works as follows:
-1. successively connect the node of highest degree to other nodes of highest degree; 
+1. successively connect the node of highest degree to other nodes of highest degree;
 2. sort the remaining nodes by degree in decreasing order;
-3. repeat the procedure. 
+3. repeat the procedure.
 
 ## References
 1. [Hakimi (1962)](https://doi.org/10.1137/0110037)
@@ -574,15 +564,15 @@ Returns a simple graph with a given finite degree sequence of non-negative integ
 function havel_hakimi_(empty_graph::SimpleGraph, degree_sequence::Vector{<:Integer}) # Please think about a decent name!
     # 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.")) 
-    # Check whether the given degree sequence is graphical 
-    isgraphical(degree_sequence) || throw(ArgumentError("The degree sequence (degree_sequence) is invalid: it must be graphical (i.e. realizable in a simple graph).")) 
-    # Check whether the given multilayer graph is undirected 
+    # 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."))
+    # Check whether the given degree sequence is graphical
+    isgraphical(degree_sequence) || throw(ArgumentError("The degree sequence (degree_sequence) is invalid: it must be graphical (i.e. realizable in a simple graph)."))
+    # Check whether the given multilayer graph is undirected
     !is_directed(empty_mg) || throw(ArgumentError("The multilayer graph (empty_mg) is invalid: it must be undirected."))
-    # Get all the multilayer vertices from the empty multilayer graph 
+    # Get all the multilayer vertices from the empty multilayer graph
     ##mvs = mv_vertices(empty_mg)
     # Get the length of the degree sequence
     ##n = length(degree_sequence)
     ##mvs_degree_dict = Dict(mv => deg for (mv, deg) in zip(mvs, degree_sequence) if deg > 0)
-end
+end

test/runtests.jl

@@ -143,4 +143,4 @@ all_interlayers = [interlayer_sg_swg, interlayer_swg_mg, interlayer_mg_vg, inter
     @testset "utilities" begin
         include("utilities.jl")
     end
-end
+end