Merge branch 'master' into no_alloc_enumerate_paths

Author: rafaqz

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"]

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

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

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)
 

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)))

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

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

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

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")
 

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