Solved bug in yen.jl (#183)

* Add maxdist to dijkstra

* Use new version of dijkstra in yen

* Fix typo test yen

* Add new test

* Add test dijkstra

* Fix type maxdist

* Change type maxdist

* Remove type `maxdist` docs

Co-authored-by: Guillaume Dalle <[email protected]>

* Remove type `maxdist` docs

Co-authored-by: Guillaume Dalle <[email protected]>

* Same for `yen`

* Update docstring

---------

Co-authored-by: Guillaume Dalle <[email protected]>

Author: aurorarossi

src/shortestpaths/dijkstra.jl

@@ -20,19 +20,21 @@ Return a [`Graphs.DijkstraState`](@ref) that contains various traversal informat
 
 
 ### Optional Arguments
-* `allpaths=false`: If true, 
+* `allpaths=false`: If true,
 
 `state.predecessors` holds a vector, indexed by vertex,
 of all the predecessors discovered during shortest-path calculations.
 This keeps track of all parents when there are multiple shortest paths available from the source.
 
-`state.pathcounts` holds a vector, indexed by vertex, of the number of shortest paths from the source to that vertex. 
+`state.pathcounts` holds 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`.
 
-* `trackvertices=false`: If true, 
+* `trackvertices=false`: If true,
 
 `state.closest_vertices` holds a vector of all vertices in the graph ordered from closest to farthest.
 
+* `maxdist` (default: `typemax(T)`) specifies the maximum path distance beyond which all path distances are assumed to be infinite (that is, they do not exist).
+
 ### Performance
 If using a sparse matrix for `distmx`, you *may* achieve better performance by passing in a transpose of its sparse transpose.
 That is, assuming `D` is the sparse distance matrix:
@@ -73,7 +75,9 @@ function dijkstra_shortest_paths(
     distmx::AbstractMatrix{T}=weights(g);
     allpaths=false,
     trackvertices=false,
-) where {T<:Real} where {U<:Integer}
+    maxdist=typemax(T)
+    ) where T <: Real where U <: Integer
+
     nvg = nv(g)
     dists = fill(typemax(T), nvg)
     parents = zeros(U, nvg)
@@ -105,6 +109,8 @@ function dijkstra_shortest_paths(
         for v in outneighbors(g, u)
             alt = d + distmx[u, v]
 
+            alt > maxdist && continue
+
             if !visited[v]
                 visited[v] = true
                 dists[v] = alt
@@ -157,8 +163,9 @@ function dijkstra_shortest_paths(
     distmx::AbstractMatrix=weights(g);
     allpaths=false,
     trackvertices=false,
+    maxdist=typemax(eltype(distmx))
 )
     return dijkstra_shortest_paths(
-        g, [src;], distmx; allpaths=allpaths, trackvertices=trackvertices
+        g, [src;], distmx; allpaths=allpaths, trackvertices=trackvertices, maxdist=maxdist
     )
 end

src/shortestpaths/yen.jl

@@ -9,7 +9,7 @@ struct YenState{T,U<:Integer} <: AbstractPathState
 end
 
 """
-    yen_k_shortest_paths(g, source, target, distmx=weights(g), K=1; maxdist=Inf);
+    yen_k_shortest_paths(g, source, target, distmx=weights(g), K=1; maxdist=typemax(T));
 
 Perform [Yen's algorithm](http://en.wikipedia.org/wiki/Yen%27s_algorithm)
 on a graph, computing k-shortest distances between `source` and `target` other vertices.
@@ -21,11 +21,11 @@ function yen_k_shortest_paths(
     target::U,
     distmx::AbstractMatrix{T}=weights(g),
     K::Int=1;
-    maxdist=Inf,
-) where {T<:Real} where {U<:Integer}
+    maxdist=typemax(T)) where {T<:Real} where {U<:Integer}
+
     source == target && return YenState{T,U}([U(0)], [[source]])
 
-    dj = dijkstra_shortest_paths(g, source, distmx)
+    dj = dijkstra_shortest_paths(g, source, distmx; maxdist)
     path = enumerate_paths(dj)[target]
     isempty(path) && return YenState{T,U}(Vector{T}(), Vector{Vector{U}}())
 
@@ -35,7 +35,7 @@ function yen_k_shortest_paths(
     B = PriorityQueue()
     gcopy = deepcopy(g)
 
-    for k in 1:(K - 1)
+    for k in 1:(K-1)
         for j in 1:length(A[k])
             # Spur node is retrieved from the previous k-shortest path, k − 1
             spurnode = A[k][j]
@@ -48,7 +48,7 @@ function yen_k_shortest_paths(
             for ppath in A
                 if length(ppath) > j && rootpath == ppath[1:j]
                     u = ppath[j]
-                    v = ppath[j + 1]
+                    v = ppath[j+1]
                     if has_edge(gcopy, u, v)
                         rem_edge!(gcopy, u, v)
                         push!(edgesremoved, (u, v))
@@ -58,7 +58,7 @@ function yen_k_shortest_paths(
 
             # Remove node of root path and calculate dist of it
             distrootpath = zero(T)
-            for n in 1:(length(rootpath) - 1)
+            for n in 1:(length(rootpath)-1)
                 u = rootpath[n]
                 nei = copy(neighbors(gcopy, u))
                 for v in nei
@@ -67,7 +67,7 @@ function yen_k_shortest_paths(
                 end
 
                 # Evaluate distance of root path
-                v = rootpath[n + 1]
+                v = rootpath[n+1]
                 distrootpath += distmx[u, v]
             end
 
@@ -76,7 +76,7 @@ function yen_k_shortest_paths(
             spurpath = enumerate_paths(djspur)[target]
             if !isempty(spurpath)
                 # Entire path is made up of the root path and spur path
-                pathtotal = [rootpath[1:(end - 1)]; spurpath]
+                pathtotal = [rootpath[1:(end-1)]; spurpath]
                 distpath = distrootpath + djspur.dists[target]
                 # Add the potential k-shortest path to the heap
                 if !haskey(B, pathtotal)

test/shortestpaths/dijkstra.jl

@@ -101,4 +101,14 @@
         dm = @inferred(dijkstra_shortest_paths(g, 1; allpaths=true, trackvertices=true))
         @test dm.closest_vertices == [1, 2, 3, 4, 5]
     end
+
+    #maximum distance setting limits paths found
+        G = cycle_graph(6)
+        add_edge!(G, 1, 3)
+        m = float([0 2 2 0 0 1; 2 0 1 0 0 0; 2 1 0 4 0 0; 0 0 4 0 1 0; 0 0 0 1 0 1; 1 0 0 0 1 0])
+
+        for g in testgraphs(G)
+            ds = @inferred(dijkstra_shortest_paths(g, 3, m;maxdist=3.0))
+            @test ds.dists == [2, 1, 0, Inf, Inf, 3]
+        end
 end

test/shortestpaths/yen.jl

@@ -111,10 +111,16 @@
     w[1, 4] = 3
     w[4, 1] = 3
     for g in testdigraphs(G)
-        ds = @inferred(yen_k_shortest_paths(G, 1, 6, w, 100))
+         ds = @inferred(yen_k_shortest_paths(g, 1, 6, w, 100))
         @test ds.dists == [4.0, 5.0, 7.0, 7.0, 8.0, 8.0, 8.0, 11.0, 11.0]
-
-        ds = @inferred(yen_k_shortest_paths(G, 1, 6, w, 100, maxdist=7))
+    
+        ds = @inferred(yen_k_shortest_paths(g, 1, 6, w, 100, maxdist=7.))
         @test ds.dists == [4.0, 5.0, 7.0, 7.0]
-    end
+     end
+
+     # Test that no paths are returned if every path is longer than maxdist
+    for g in testdigraphs(cycle_digraph(10))
+        ds = @inferred(yen_k_shortest_paths(g, 2, 1, weights(g), 2, maxdist=2))
+        @test isempty(ds.paths)
+     end
 end