Add disgraphical and update test

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

Author: 3 people

src/utilities.jl

@@ -359,28 +359,40 @@ Check whether `A` is symmetric (within `zero(T)`).
 isapproxsymmetric(A::Matrix{T}) where {T<:Integer} = all(abs.(A .- A') .<= zero(T))
 
 """
-    isdigraphical(indegree_sequence::Vector{<:Integer}, outdegree_sequence::Vector{<:Integer} )
-
-Return true if the degree sequences `indegree_sequence` and `outdegree_sequence` satisfy the (simple) digraph realization problem.
-
-Two sequences of integers of integers satisfy the (simple) digraph realization problem, if there exists a simple directed graph where the indegrees of its vertices form that first sequence and the outdegrees the second.
+    isdigraphical(indegree_sequence::AbstractVector{<:Integer}, outdegree_sequence::AbstractVector{<:Integer},)
+Check whether the given indegree sequence and outdegree sequence are digraphical, that is whether they can be the indegree and outdegree sequence of a digraph.
 
 ### Implementation Notes
-According to Fulkerson-Chen-Anstee theorem, a sequence ``\\{(a_1, b_1), ...,(a_n, b_n)\\}`` (sorted in descending order of a) is graphic iff the sum of vertex degrees is even and the sequence obeys the property -
+According to Fulkerson-Chen-Anstee theorem, a sequence ``\\{(a_1, b_1), ...,(a_n, b_n)\\}`` (sorted in descending order of a) is graphic iff the sum of vertex degrees is even and  ``\\sum_{i = 1}^{n} a_i = \\sum_{i = 1}^{n} b_i\\}`` and the sequence obeys the property -
 ```math
 \\sum_{i=1}^{r} a_i \\leq \\sum_{i=r+1}^n min(r-1,b_i) + \\sum_{i=r+1}^n min(r,b_i)
 ```
-for each integer ``r \\leq n-1``.
-"""
-function isdigraphical(indegree_sequence::Vector{<:Integer}, outdegree_sequence::Vector{<:Integer} )
+for each integer r <= n-1. 
+"""
+function isdigraphical(
+    indegree_sequence::AbstractVector{<:Integer},
+    outdegree_sequence::AbstractVector{<:Integer},
+)
+    # Check whether the degree sequences have the same length 
+    length(indegree_sequence) == length(outdegree_sequence) || throw(
+        ArgumentError("The indegree and outdegree sequences must have the same length.")
+    )
+    # Check whether the degree sequence is empty
+    !(isempty(indegree_sequence) && isempty(outdegree_sequence)) || return true
+    # Check whether the degree sequences have only non-negative values
+    all(indegree_sequence .>= 0) || throw(
+        ArgumentError("The indegree sequence must contain non-negative integers only.")
+    )
+    all(outdegree_sequence .>= 0) || throw(
+        ArgumentError("The outdegree sequence must contain non-negative integers only.")
+    )
 
     n = length(indegree_sequence)
-
     n == length(outdegree_sequence) || return false
 
     sum(indegree_sequence) == sum(outdegree_sequence) || return false
 
-    _sortperm = sortperm(indegree_sequence, rev = true)
+    _sortperm = sortperm(indegree_sequence; rev=true)
 
     sorted_indegree_sequence = indegree_sequence[_sortperm]
     sorted_outdegree_sequence = outdegree_sequence[_sortperm]
@@ -395,27 +407,25 @@ function isdigraphical(indegree_sequence::Vector{<:Integer}, outdegree_sequence:
     # with the line
     # cum_min -= mindeg[r]
     # inside the for loop below, work as well, but the values of `cum_min` at each iteration differ. To be on the safe side we implemented it as in https://en.wikipedia.org/wiki/Fulkerson%E2%80%93Chen%E2%80%93Anstee_theorem
-#=     mindeg = Vector{Int64}(undef, n)
-    @inbounds for i = 1:n
-        mindeg[i] = min(i, sorted_outdegree_sequence[i])
-    end
-    cum_min = sum(mindeg) =#
+    #=     mindeg = Vector{Int64}(undef, n)
+        @inbounds for i = 1:n
+            mindeg[i] = min(i, sorted_outdegree_sequence[i])
+        end
+        cum_min = sum(mindeg) =#
     # Similarly for `outdegree_min_sum`.
 
-    @inbounds for r = 1:(n - 1)
-
+    @inbounds for r in 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])
-
+        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])
         cond = indegree_sum <= (outdegree_min_sum + cum_min)
-
         cond || return false
     end
 
     return true
 end
 
+
 """
     _random_undirected_configuration(empty_mg::M, degree_sequence::Vector{ <: Integer}) where {T,U,M <: MultilayerGraph{T,U}}
 
@@ -549,6 +559,7 @@ Internal function. Converts `cart_index` to an integer index such that it corres
 cartIndexTovecIndex(cart_index::Union{NTuple{N, Integer},CartesianIndex}, tensor_size::NTuple{N, <: Integer} ) where N = cart_index[1] + sum( collect(Tuple(cart_index)[2:end] .- 1) .* cumprod(tensor_size[1:end-1]))
 
 
+# TODO:
 """
     havel_hakimi_(empty_graph::SimpleGraph, degree_sequence::Vector{<:Integer})
 

test/utilities.jl

@@ -2,4 +2,9 @@
 const A = reshape(rand(1:9, 1000), 10, 10, 10)
 carts_idxs = CartesianIndices(A)
 vec_idxs = MultilayerGraphs.cartIndexTovecIndex.(carts_idxs, Ref(size(A)))
-@test all(getindex.(Ref(A), carts_idxs) .== getindex.(Ref(A), vec_idxs) ) 
+@test all(getindex.(Ref(A), carts_idxs) .== getindex.(Ref(A), vec_idxs) ) 
+# Test directed simple graphicality
+sdg = SimpleDiGraph(10, 90)
+@test @inferred(isdigraphical(indegree(sdg), outdegree(sdg)))
+@test !@inferred(isdigraphical([1, 1, 1], [1, 1, 0]))
+@test @inferred(isdigraphical(Integer[], Integer[]))