Merge branch 'master' into no_alloc_enumerate_paths

rafaqz · rafaqz · commit a1f8b6f19203 · 2025-06-03T09:00:34.000+02:00
diff --git a/Project.toml b/Project.toml
@@ -1,6 +1,6 @@
 name = "Graphs"
 uuid = "86223c79-3864-5bf0-83f7-82e725a168b6"
-version = "1.12.0"
+version = "1.12.1"
 
 [deps]
 ArnoldiMethod = "ec485272-7323-5ecc-a04f-4719b315124d"
@@ -42,6 +42,7 @@ SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d"
 
 [targets]
-test = ["Aqua", "Base64", "DelimitedFiles", "Documenter", "JET", "JuliaFormatter", "LinearAlgebra", "Pkg", "Random", "SparseArrays", "StableRNGs", "Statistics", "Test"]
+test = ["Aqua", "Base64", "DelimitedFiles", "Documenter", "JET", "JuliaFormatter", "LinearAlgebra", "Pkg", "Random", "SparseArrays", "StableRNGs", "Statistics", "Test", "Unitful"]
diff --git a/src/Parallel/distance.jl b/src/Parallel/distance.jl
@@ -2,7 +2,7 @@
 
 function eccentricity(
     g::AbstractGraph, vs=vertices(g), distmx::AbstractMatrix{T}=weights(g)
-) where {T<:Real}
+) where {T<:Number}
     vlen = length(vs)
     eccs = SharedVector{T}(vlen)
     @sync @distributed for i in 1:vlen
diff --git a/src/Parallel/shortestpaths/bellman-ford.jl b/src/Parallel/shortestpaths/bellman-ford.jl
@@ -2,7 +2,7 @@ function bellman_ford_shortest_paths(
     g::AbstractGraph{U},
     sources::AbstractVector{<:Integer},
     distmx::AbstractMatrix{T}=weights(g),
-) where {T<:Real} where {U<:Integer}
+) where {T<:Number} where {U<:Integer}
     nvg = nv(g)
     active = Set{U}()
     sizehint!(active, nv(g))
@@ -30,7 +30,7 @@ function _loop_body!(
     dists::Vector{T},
     parents::Vector{U},
     active::Set{U},
-) where {T<:Real} where {U<:Integer}
+) where {T<:Number} where {U<:Integer}
     prev_dists = deepcopy(dists)
 
     tmp_active = collect(active)
@@ -58,7 +58,7 @@ end
 
 function has_negative_edge_cycle(
     g::AbstractGraph{U}, distmx::AbstractMatrix{T}
-) where {T<:Real} where {U<:Integer}
+) where {T<:Number} where {U<:Integer}
     try
         Parallel.bellman_ford_shortest_paths(g, vertices(g), distmx)
     catch e
diff --git a/src/Parallel/shortestpaths/dijkstra.jl b/src/Parallel/shortestpaths/dijkstra.jl
@@ -3,7 +3,7 @@
 
 An [`AbstractPathState`](@ref) designed for Parallel.dijkstra_shortest_paths calculation.
 """
-struct MultipleDijkstraState{T<:Real,U<:Integer} <: AbstractPathState
+struct MultipleDijkstraState{T<:Number,U<:Integer} <: AbstractPathState
     dists::Matrix{T}
     parents::Matrix{U}
 end
@@ -18,7 +18,7 @@ traversal information.
 """
 function dijkstra_shortest_paths(
     g::AbstractGraph{U}, sources=vertices(g), distmx::AbstractMatrix{T}=weights(g)
-) where {T<:Real} where {U}
+) where {T<:Number} where {U}
     n_v = nv(g)
     r_v = length(sources)
 
diff --git a/src/Parallel/shortestpaths/floyd-warshall.jl b/src/Parallel/shortestpaths/floyd-warshall.jl
@@ -1,7 +1,7 @@
 # Helper function used due to performance bug in @threads.
 function _loopbody!(
     pivot::U, nvg::U, dists::Matrix{T}, parents::Matrix{U}
-) where {T<:Real} where {U<:Integer}
+) where {T<:Number} where {U<:Integer}
     # Relax dists[u, v] = min(dists[u, v], dists[u, pivot]+dists[pivot, v]) for all u, v
     @inbounds @threads for v in one(U):nvg
         d = dists[pivot, v]
@@ -26,7 +26,7 @@ end
 
 function floyd_warshall_shortest_paths(
     g::AbstractGraph{U}, distmx::AbstractMatrix{T}=weights(g)
-) where {T<:Real} where {U<:Integer}
+) where {T<:Number} where {U<:Integer}
     nvg = nv(g)
     dists = fill(typemax(T), (Int(nvg), Int(nvg)))
     parents = zeros(U, (Int(nvg), Int(nvg)))
diff --git a/src/Parallel/shortestpaths/johnson.jl b/src/Parallel/shortestpaths/johnson.jl
@@ -4,7 +4,7 @@ using Compat
 
 function johnson_shortest_paths(
     g::AbstractGraph{U}, distmx::AbstractMatrix{T}=weights(g)
-) where {T<:Real} where {U<:Integer}
+) where {T<:Number} where {U<:Integer}
     nvg = nv(g)
     type_distmx = typeof(distmx)
     # Change when parallel implementation of Bellman Ford available
diff --git a/src/connectivity.jl b/src/connectivity.jl
@@ -798,24 +798,49 @@ function isgraphical(degs::AbstractVector{<:Integer})
     !isempty(degs) || return true
     # Check whether the sum of degrees is even
     iseven(sum(degs)) || return false
-    # Check that all degrees are non negative and less than n-1
+    # Compute the length of the degree sequence
     n = length(degs)
+    # Check that all degrees are non negative and less than n-1
     all(0 .<= degs .<= n - 1) || return false
     # Sort the degree sequence in non-increasing order
     sorted_degs = sort(degs; rev=true)
-    # Compute the length of the degree sequence
+    # Initialise a sum variable
     cur_sum = zero(UInt64)
-    # Compute the minimum of each degree and the corresponding index
-    mindeg = Vector{UInt64}(undef, n)
-    @inbounds for i in 1:n
-        mindeg[i] = min(i, sorted_degs[i])
-    end
+    right_deg_sum = zero(UInt64)
+    # Initalise a pointer to track the smallest index with degree greater than r
+    ptr = n
     # Check if the degree sequence satisfies the Erdös-Gallai condition
-    cum_min = sum(mindeg)
     @inbounds for r in 1:(n - 1)
         cur_sum += sorted_degs[r]
-        cum_min -= mindeg[r]
-        cond = cur_sum <= (r * (r - 1) + cum_min)
+        #  Calculate the sum of the minimum of r and the degrees of the vertices
+        min_idx = r + 1
+        while ptr >= min_idx
+            if sorted_degs[ptr] <= r
+                # left_deg_sum = sum_{ptr+1}^n d_i
+                right_deg_sum += sorted_degs[ptr]
+                # move pointer to the 1-slot left
+                ptr -= 1
+            else
+                # the ptr points to the degree greater than r
+                break
+            end
+        end
+        # calculate min_deg_sum: sum_{r+1}^n min(r, d_i)
+        if ptr < min_idx
+            # all required degrees are less than r
+            # ptr is min_idx - 1
+            min_deg_sum = right_deg_sum
+            # prepare for the next iteration
+            # shift ptr to the right
+            ptr += 1
+            # reduce right_deg_sum
+            right_deg_sum -= sorted_degs[ptr]
+        else
+            # d_i with i between ptr and min_idx are greater than r 
+            min_deg_sum = (ptr - r) * r + right_deg_sum
+        end
+        # Check the Erdös-Gallai condition
+        cond = cur_sum <= (r * (r - 1) + min_deg_sum)
         cond || return false
     end
     return true
diff --git a/src/cycles/karp.jl b/src/cycles/karp.jl
@@ -3,7 +3,7 @@
 # Discrete Mathematics, 1978, 23, 309 - 311
 function _karp_minimum_cycle_mean(
     g::AbstractGraph, distmx::AbstractMatrix{T}, component::Vector{U}
-) where {T<:Real} where {U<:Integer}
+) where {T<:Number} where {U<:Integer}
     v2j = Dict{U,Int}()
     for (j, v) in enumerate(component)
         v2j[v] = j
diff --git a/src/distance.jl b/src/distance.jl
@@ -73,7 +73,7 @@ julia> eccentricity(g, [1; 2], [0 2 0; 0.5 0 0.5; 0 2 0])
 """
 function eccentricity(
     g::AbstractGraph, v::Integer, distmx::AbstractMatrix{T}=weights(g)
-) where {T<:Real}
+) where {T<:Number}
     e = maximum(dijkstra_shortest_paths(g, v, distmx).dists)
     e == typemax(T) && @warn("Infinite path length detected for vertex $v")
 
diff --git a/src/graphcut/normalized_cut.jl b/src/graphcut/normalized_cut.jl
@@ -201,6 +201,6 @@ function normalized_cut(
     thres::Real,
     W::AbstractMatrix{T}=adjacency_matrix(g),
     num_cuts::Int=10,
-) where {T<:Real}
+) where {T<:Number}
     return _recursive_normalized_cut(W, thres, num_cuts)
 end
diff --git a/src/interface.jl b/src/interface.jl
@@ -183,7 +183,7 @@ vertices(g::AbstractGraph) = _NI("vertices")
     edges(g)
 
 Return (an iterator to or collection of) the edges of a graph.
-For `AbstractSimpleGraph`s it returns a `SimpleEdgeIter`.
+For `AbstractSimpleGraph`s it returns a `SimpleEdgeIter` (lexicographical order).
 The expressions `e in edges(g)` and `e ∈ edges(g)` evaluate as
 calls to [`has_edge`](@ref).
 
diff --git a/src/operators.jl b/src/operators.jl
@@ -405,7 +405,7 @@ end
 # """Provides multiplication of a graph `g` by a vector `v` such that spectral
 # graph functions in [GraphMatrices.jl](https://github.com/jpfairbanks/GraphMatrices.jl) can utilize Graphs natively.
 # """
-function *(g::AbstractGraph, v::Vector{T}) where {T<:Real}
+function *(g::AbstractGraph, v::Vector{T}) where {T<:Number}
     length(v) == nv(g) || throw(ArgumentError("Vector size must equal number of vertices"))
     y = zeros(T, nv(g))
     for e in edges(g)
diff --git a/src/shortestpaths/bellman-ford.jl b/src/shortestpaths/bellman-ford.jl
@@ -22,7 +22,7 @@ An `AbstractPathState` designed for Bellman-Ford shortest-paths calculations.
 - `parents::Vector{U}`: `parents[v]` is the predecessor of vertex `v` on the shortest path from the source to `v`
 - `dists::Vector{T}`: `dists[v]` is the length of the shortest path from the source to `v`
 """
-struct BellmanFordState{T<:Real,U<:Integer} <: AbstractPathState
+struct BellmanFordState{T<:Number,U<:Integer} <: AbstractPathState
     parents::Vector{U}
     dists::Vector{T}
 end
@@ -40,7 +40,7 @@ function bellman_ford_shortest_paths(
     graph::AbstractGraph{U},
     sources::AbstractVector{<:Integer},
     distmx::AbstractMatrix{T}=weights(graph),
-) where {T<:Real} where {U<:Integer}
+) where {T<:Number} where {U<:Integer}
     nvg = nv(graph)
     active = falses(nvg)
     active[sources] .= true
@@ -76,15 +76,15 @@ end
 
 function bellman_ford_shortest_paths(
     graph::AbstractGraph{U}, v::Integer, distmx::AbstractMatrix{T}=weights(graph);
-) where {T<:Real} where {U<:Integer}
+) where {T<:Number} where {U<:Integer}
     return bellman_ford_shortest_paths(graph, [v], distmx)
 end
 
 has_negative_edge_cycle(g::AbstractGraph) = false
 
 function has_negative_edge_cycle(
     g::AbstractGraph{U}, distmx::AbstractMatrix{T}
-) where {T<:Real} where {U<:Integer}
+) where {T<:Number} where {U<:Integer}
     try
         bellman_ford_shortest_paths(g, collect_if_not_vector(vertices(g)), distmx)
     catch e
diff --git a/src/shortestpaths/desopo-pape.jl b/src/shortestpaths/desopo-pape.jl
@@ -8,7 +8,7 @@ An [`AbstractPathState`](@ref) designed for D`Esopo-Pape shortest-path calculati
 - `parents::Vector{U}`: `parents[v]` is the predecessor of vertex `v` on the shortest path from the source to `v`
 - `dists::Vector{T}`: `dists[v]` is the length of the shortest path from the source to `v`
 """
-struct DEsopoPapeState{T<:Real,U<:Integer} <: AbstractPathState
+struct DEsopoPapeState{T<:Number,U<:Integer} <: AbstractPathState
     parents::Vector{U}
     dists::Vector{T}
 end
@@ -47,7 +47,7 @@ julia> ds.dists
 """
 function desopo_pape_shortest_paths(
     g::AbstractGraph, src::Integer, distmx::AbstractMatrix{T}=weights(g)
-) where {T<:Real}
+) where {T<:Number}
     U = eltype(g)
     nvg = nv(g)
     (src in 1:nvg) || throw(DomainError(src, "src should be in between 1 and $nvg"))
diff --git a/src/shortestpaths/dijkstra.jl b/src/shortestpaths/dijkstra.jl
@@ -11,7 +11,7 @@ An [`AbstractPathState`](@ref) designed for Dijkstra shortest-paths calculations
 - `pathcounts::Vector{Float64}`: a vector, indexed by vertex, of the number of shortest paths from the source to that vertex. The path count of a source vertex is always `1.0`. The path count of an unreached vertex is always `0.0`.
 - `closest_vertices::Vector{U}`: a vector of all vertices in the graph ordered from closest to farthest.
 """
-struct DijkstraState{T<:Real,U<:Integer} <: AbstractPathState
+struct DijkstraState{T<:Number,U<:Integer} <: AbstractPathState
     parents::Vector{U}
     dists::Vector{T}
     predecessors::Vector{Vector{U}}
@@ -73,7 +73,7 @@ function dijkstra_shortest_paths(
     allpaths=false,
     trackvertices=false,
     maxdist=typemax(T),
-) where {T<:Real} where {U<:Integer}
+) where {T<:Number} where {U<:Integer}
     nvg = nv(g)
     dists = fill(typemax(T), nvg)
     parents = zeros(U, nvg)
diff --git a/src/shortestpaths/floyd-warshall.jl b/src/shortestpaths/floyd-warshall.jl
@@ -27,7 +27,7 @@ Space complexity is on the order of `O(|V|^2)`.
 """
 function floyd_warshall_shortest_paths(
     g::AbstractGraph{U}, distmx::AbstractMatrix{T}=weights(g)
-) where {T<:Real} where {U<:Integer}
+) where {T<:Number} where {U<:Integer}
     nvg = nv(g)
     # if we do checkbounds here, we can use @inbounds later
     checkbounds(distmx, Base.OneTo(nvg), Base.OneTo(nvg))
diff --git a/src/shortestpaths/johnson.jl b/src/shortestpaths/johnson.jl
@@ -9,7 +9,7 @@ An [`AbstractPathState`](@ref) designed for Johnson shortest-paths calculations.
 - `dists::Matrix{T}`: `dists[u, v]` is the length of the shortest path from `u` to `v` 
 - `parents::Matrix{U}`: `parents[u, v]` is the predecessor of vertex `v` on the shortest path from `u` to `v`
 """
-struct JohnsonState{T<:Real,U<:Integer} <: AbstractPathState
+struct JohnsonState{T<:Number,U<:Integer} <: AbstractPathState
     dists::Matrix{T}
     parents::Matrix{U}
 end
@@ -29,7 +29,7 @@ Complexity: `O(|V|*|E|)`
 """
 function johnson_shortest_paths(
     g::AbstractGraph{U}, distmx::AbstractMatrix{T}=weights(g)
-) where {T<:Real} where {U<:Integer}
+) where {T<:Number} where {U<:Integer}
     nvg = nv(g)
     type_distmx = typeof(distmx)
     # Change when parallel implementation of Bellman Ford available
@@ -71,7 +71,7 @@ end
 
 function enumerate_paths(
     s::JohnsonState{T,U}, v::Integer
-) where {T<:Real} where {U<:Integer}
+) where {T<:Number} where {U<:Integer}
     pathinfo = s.parents[v, :]
     paths = Vector{Vector{U}}()
     for i in 1:length(pathinfo)
diff --git a/src/shortestpaths/spfa.jl b/src/shortestpaths/spfa.jl
@@ -46,7 +46,7 @@ ERROR: Graphs.NegativeCycleError()
 """
 function spfa_shortest_paths(
     graph::AbstractGraph{U}, source::Integer, distmx::AbstractMatrix{T}=weights(graph)
-) where {T<:Real} where {U<:Integer}
+) where {T<:Number} where {U<:Integer}
     nvg = nv(graph)
 
     (source in 1:nvg) ||
@@ -115,7 +115,7 @@ false
 """
 function has_negative_edge_cycle_spfa(
     g::AbstractGraph{U}, distmx::AbstractMatrix{T}
-) where {T<:Real} where {U<:Integer}
+) where {T<:Number} where {U<:Integer}
     try
         spfa_shortest_paths(g, 1, distmx)
     catch e
diff --git a/src/shortestpaths/yen.jl b/src/shortestpaths/yen.jl
@@ -30,7 +30,7 @@ function yen_k_shortest_paths(
     distmx::AbstractMatrix{T}=weights(g),
     K::Int=1;
     maxdist=typemax(T),
-) where {T<:Real} where {U<:Integer}
+) where {T<:Number} where {U<:Integer}
     source == target && return YenState{T,U}([U(0)], [[source]])
 
     dj = dijkstra_shortest_paths(g, source, distmx; maxdist)
diff --git a/src/spanningtrees/boruvka.jl b/src/spanningtrees/boruvka.jl
@@ -14,7 +14,7 @@ function boruvka_mst end
 
 @traitfn function boruvka_mst(
     g::AG::(!IsDirected), distmx::AbstractMatrix{T}=weights(g); minimize=true
-) where {T<:Real,U,AG<:AbstractGraph{U}}
+) where {T<:Number,U,AG<:AbstractGraph{U}}
     djset = IntDisjointSets(nv(g))
     # maximizing Z is the same as minimizing -Z
     # mode will indicate the need for the -1 multiplication
diff --git a/src/spanningtrees/kruskal.jl b/src/spanningtrees/kruskal.jl
@@ -11,7 +11,7 @@ function kruskal_mst end
 # see https://github.com/mauro3/SimpleTraits.jl/issues/47#issuecomment-327880153 for syntax
 @traitfn function kruskal_mst(
     g::AG::(!IsDirected), distmx::AbstractMatrix{T}=weights(g); minimize=true
-) where {T<:Real,U,AG<:AbstractGraph{U}}
+) where {T<:Number,U,AG<:AbstractGraph{U}}
     connected_vs = IntDisjointSets(nv(g))
 
     mst = Vector{edgetype(g)}()
diff --git a/src/spanningtrees/prim.jl b/src/spanningtrees/prim.jl
@@ -8,7 +8,7 @@ Return a vector of edges.
 function prim_mst end
 @traitfn function prim_mst(
     g::AG::(!IsDirected), distmx::AbstractMatrix{T}=weights(g)
-) where {T<:Real,U,AG<:AbstractGraph{U}}
+) where {T<:Number,U,AG<:AbstractGraph{U}}
     nvg = nv(g)
 
     pq = PriorityQueue{U,T}()
diff --git a/src/traversals/maxadjvisit.jl b/src/traversals/maxadjvisit.jl
@@ -18,7 +18,7 @@ assumed to be 1.
 """
 @traitfn function mincut(
     g::::(!IsDirected), distmx::AbstractMatrix{T}=weights(g)
-) where {T<:Real}
+) where {T<:Number}
     nvg = nv(g)
     U = eltype(g)
 
@@ -140,7 +140,7 @@ function maximum_adjacency_visit(
     log::Bool=false,
     io::IO=stdout,
     s::U=one(U),
-) where {U,T<:Real}
+) where {U,T<:Number}
     pq = PriorityQueue{U,T}(Base.Order.Reverse)
     vertices_order = Vector{U}()
     has_key = ones(Bool, nv(g))
diff --git a/test/connectivity.jl b/test/connectivity.jl
@@ -316,6 +316,7 @@
     @test @inferred(isgraphical([2, 2, 2]))
     @test @inferred(isgraphical(fill(3, 10)))
     @test @inferred(isgraphical(Integer[]))
+    @test @inferred(!isgraphical([4, 2, 2, 2, 0]))
     ##@test !@inferred(isgraphical([2]))
 
     # Test simple digraphicality
diff --git a/test/runtests.jl b/test/runtests.jl
diff --git a/test/shortestpaths/yen.jl b/test/shortestpaths/yen.jl
