add LEMONWPMPAlgorithm and make it default instead of the BlossomV

Author: Krastanov

Project.toml

@@ -1,14 +1,15 @@
 name = "GraphsMatching"
 uuid = "c3af3a8c-b79e-4b01-bf44-c718d7e0e0d6"
 authors = ["JuliaGraphs"]
-version = "0.2.0"
+version = "0.2.1"
 
 [deps]
 BlossomV = "6c721016-9dae-5d90-abf6-67daaccb2332"
 Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
 Hungarian = "e91730f6-4275-51fb-a7a0-7064cfbd3b39"
 JuMP = "4076af6c-e467-56ae-b986-b466b2749572"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+LEMONGraphs = "14b1564f-c77f-4800-9e89-efd961faef7c"
 MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 
@@ -17,6 +18,7 @@ BlossomV = "0.4"
 Graphs = "1.4, 1.7"
 Hungarian = "0.4, 0.6, 0.7"
 JuMP = "1"
+LEMONGraphs = "0.1.0"
 MathOptInterface = "1"
 julia = "1"
 

src/GraphsMatching.jl

@@ -7,10 +7,19 @@ using SparseArrays: spzeros
 using JuMP
 using MathOptInterface
 const MOI = MathOptInterface
-import BlossomV # 'using BlossomV'  leads to naming conflicts with JuMP
+import BlossomV
+import LEMONGraphs
 using Hungarian
 
-export MatchingResult, maximum_weight_matching, maximum_weight_matching_reduction, maximum_weight_maximal_matching, minimum_weight_perfect_matching, HungarianAlgorithm, LPAlgorithm
+export MatchingResult,
+    maximum_weight_matching,
+    maximum_weight_matching_reduction,
+    maximum_weight_maximal_matching,
+    minimum_weight_perfect_matching,
+    HungarianAlgorithm,
+    LPAlgorithm,
+    BlossomVAlgorithm,
+    LEMONMWPMAlgorithm
 
 """
     struct MatchingResult{U}

src/blossomv.jl

@@ -13,7 +13,8 @@ Edges in `g` not present in `w` will not be considered for the matching.
 You can use the `algorithm` argument to specify the algorithm to use.
 
 A `cutoff` argument can be given, to reduce the computational time by
-excluding edges with weights higher than the cutoff.
+excluding edges with weights higher than the cutoff (effective only for some algorithms,
+not for the default `LEMONMWPMAlgorithm`).
 
 When the weights are non-integer types, the keyword argument `tmaxscale` can be used to
 scale the weights to integer values.
@@ -56,18 +57,27 @@ If BlossomV.jl does not work on your system,
 consider using the LEMONGraphs.jl algorithm instead (the default algorithm),
 which we distribute precompiled on all platforms.
 
-See also: [`minimum_weight_perfect_matching`](@ref)
+See also: [`minimum_weight_perfect_matching`](@ref), [`LEMONMWPMAlgorithm`](@ref)
 """
 struct BlossomVAlgorithm <: AbstractMinimumWeightPerfectMatchingAlgorithm end
 
+"""
+    LEMONMWPMAlgorithm()
+
+Use the LEMON C++ implementation of minimum weight perfect matching.
+
+See also: [`minimum_weight_perfect_matching`](@ref), [`BlossomVAlgorithm`](@ref)
+"""
+struct LEMONMWPMAlgorithm <: AbstractMinimumWeightPerfectMatchingAlgorithm end
+
 function minimum_weight_perfect_matching(
     g::Graph, w::Dict{E,U}
 ) where {U<:Integer,E<:Edge}
-    return minimum_weight_perfect_matching(g, w, BlossomVAlgorithm())
+    return minimum_weight_perfect_matching(g, w, LEMONMWPMAlgorithm())
 end
 
 function minimum_weight_perfect_matching(
-    g::Graph, w::Dict{E,U}, cutoff, algorithm::AbstractMinimumWeightPerfectMatchingAlgorithm=BlossomVAlgorithm(); kws...
+    g::Graph, w::Dict{E,U}, cutoff, algorithm::AbstractMinimumWeightPerfectMatchingAlgorithm=LEMONMWPMAlgorithm(); kws...
 ) where {U<:Real,E<:Edge}
     wnew = Dict{E,U}()
     for (e, c) in w
@@ -79,7 +89,7 @@ function minimum_weight_perfect_matching(
 end
 
 function minimum_weight_perfect_matching(
-    g::Graph, w::Dict{E,U}, algorithm::AbstractMinimumWeightPerfectMatchingAlgorithm=BlossomVAlgorithm(); tmaxscale=10.0
+    g::Graph, w::Dict{E,U}, algorithm::AbstractMinimumWeightPerfectMatchingAlgorithm=LEMONMWPMAlgorithm(); tmaxscale=10.0
 ) where {U<:AbstractFloat,E<:Edge}
     wnew = Dict{E,Int32}()
     cmax = maximum(values(w))
@@ -95,7 +105,7 @@ function minimum_weight_perfect_matching(
     for i in 1:nv(g)
         j = match.mate[i]
         if j > i
-            weight += w[E(i, j)]
+            weight += get(w, E(i, j), zero(U))
         end
     end
     return MatchingResult(weight, match.mate)
@@ -119,3 +129,10 @@ function minimum_weight_perfect_matching(g::Graph, w::Dict{E,U}, ::BlossomVAlgor
     end
     return MatchingResult(totweight, mate)
 end
+
+function minimum_weight_perfect_matching(g::Graph, w::Dict{E,U}, ::LEMONMWPMAlgorithm) where {U<:Integer,E<:Edge}
+    max = 2*abs(maximum(values(w)))
+    weights = [-get(w, e, max) for e in edges(g)]
+    totweight, mate = LEMONGraphs.maxweightedperfectmatching(g, weights)
+    return MatchingResult(-totweight, mate)
+end

test/runtests.jl

@@ -259,11 +259,15 @@ using LinearAlgebra: I
 
 
     @testset "minimum_weight_perfect_matching" begin
+        for algorithm in [
+            BlossomVAlgorithm(),
+            LEMONMWPMAlgorithm(),
+        ]
 
         w = Dict(Edge(1, 2) => 500)
         g = Graph(2)
         add_edge!(g, 1, 2)
-        match = minimum_weight_perfect_matching(g, w)
+        match = minimum_weight_perfect_matching(g, w, algorithm)
         @test match.mate[1] == 2
 
 
@@ -276,7 +280,7 @@ using LinearAlgebra: I
         )
 
         g = complete_graph(4)
-        match = minimum_weight_perfect_matching(g, w)
+        match = minimum_weight_perfect_matching(g, w, algorithm)
         @test match.mate[1] == 2
         @test match.mate[2] == 1
         @test match.mate[3] == 4
@@ -291,7 +295,7 @@ using LinearAlgebra: I
             Edge(2, 4) => 1000,
         )
         g = complete_graph(4)
-        match = minimum_weight_perfect_matching(g, w)
+        match = minimum_weight_perfect_matching(g, w, algorithm)
         @test match.mate[1] == 3
         @test match.mate[2] == 4
         @test match.mate[3] == 1
@@ -305,7 +309,7 @@ using LinearAlgebra: I
         w[Edge(2, 3)] = -11
         w[Edge(2, 4)] = -1
 
-        match = minimum_weight_perfect_matching(g, w)
+        match = minimum_weight_perfect_matching(g, w, algorithm)
         @test match.mate[1] == 4
         @test match.mate[4] == 1
         @test match.mate[2] == 3
@@ -321,7 +325,7 @@ using LinearAlgebra: I
         w[Edge(2, 4)] = 2
         w[Edge(1, 2)] = 100
 
-        match = minimum_weight_perfect_matching(g, w, 50)
+        match = minimum_weight_perfect_matching(g, w, 50, algorithm)
         @test match.mate[1] == 4
         @test match.mate[4] == 1
         @test match.mate[2] == 3
@@ -338,9 +342,11 @@ using LinearAlgebra: I
         g = Graph([Edge(1, 2)])
         wFloat = Dict(Edge(1, 2) => 2.0)
         wInt = Dict(Edge(1, 2) => 2)
-        matchFloat = minimum_weight_perfect_matching(g, wFloat)
-        matchInt = minimum_weight_perfect_matching(g, wInt)
+        matchFloat = minimum_weight_perfect_matching(g, wFloat, algorithm)
+        matchInt = minimum_weight_perfect_matching(g, wInt, algorithm)
         @test matchFloat.mate == matchInt.mate
         @test matchFloat.weight == matchInt.weight
+
+        end
     end
 end