JuMP/MOI to new version v0.20/0.9 (#16)

* JuMP/MOI to new version v0.20/0.9

* removed julia 0.7 added 1.2 and changed readme

* require julia 1

* Require -> Project.toml

* added/removed spaces based on review

Author: Wikunia

Project.toml

@@ -9,14 +9,15 @@ Hungarian = "e91730f6-4275-51fb-a7a0-7064cfbd3b39"
 JuMP = "4076af6c-e467-56ae-b986-b466b2749572"
 LightGraphs = "093fc24a-ae57-5d10-9952-331d41423f4d"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
-MathProgBase = "fdba3010-5040-5b88-9595-932c9decdf73"
+MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 
 [compat]
 BlossomV = "0.4"
 Hungarian = "0.4"
-JuMP = "0.18"
+JuMP = "0.20"
 LightGraphs = "1.2"
+MathOptInterface = "0.9"
 julia = "1"
 
 [extras]

README.md

@@ -16,8 +16,8 @@ containing the `mate` and `weight` fields.
 ### Perfect matching
 
 ```julia
-g =CompleteGraph(4)
-w =Dict{Edge,Float64}()
+g = complete_graph(4)
+w = Dict{Edge,Float64}()
 w[Edge(1,3)] = 10
 w[Edge(1,4)] = 0.5
 w[Edge(2,3)] = 11
@@ -36,17 +36,15 @@ match = minimum_weight_perfect_matching(g, w, 50)
 ### Maximum weight matching
 
 A maximum weight matching is solved as a Linear Programming
-problem and requires a LP solver respecting the [MathProgBase](https://github.com/JuliaOpt/MathProgBase.jl) solver
-interface. See MathProgBase 
-[documentation](http://mathprogbasejl.readthedocs.io/en/latest/solvers.html) for more details.
+problem and requires an LP optimizer for bipartite graphs and a MILP solver for general graphs respecting the [MathOptInterface](https://github.com/JuliaOpt/MathOptInterface.jl) optimizer interface. A list of solvers can be found in the [JuMP documentation](http://www.juliaopt.org/JuMP.jl/v0.19.0/installation/#Getting-Solvers-1).
 
 ```julia
-using Cbc: CbcSolver #import a LP solver
-g = CompleteGraph(3)
+using JuMP, Cbc #import a MILP solver
+g = complete_graph(3)
 w = zeros(3,3)
 w[1,2] = 1
 w[3,2] = 1
 w[1,3] = 1
-match = maximum_weight_matching(g,CbcSolver(),w)
+match = maximum_weight_matching(g,with_optimizer(Cbc.Optimizer, logLevel=0),w)
 # match.weight ≈ 1
 ```

src/LightGraphsMatching.jl

@@ -5,7 +5,8 @@ using LightGraphs
 using SparseArrays: spzeros
 
 using JuMP
-using MathProgBase: AbstractMathProgSolver
+using MathOptInterface
+const MOI = MathOptInterface
 import BlossomV # 'using BlossomV'  leads to naming conflicts with JuMP
 using Hungarian
 

src/lp.jl

@@ -1,8 +1,8 @@
-function maximum_weight_maximal_matching_lp(g::Graph, solver::AbstractMathProgSolver, w::AbstractMatrix{T}, cutoff::R) where {T<:Real, R<:Real}
+function maximum_weight_maximal_matching_lp(g::Graph, solver::JuMP.OptimizerFactory, w::AbstractMatrix{T}, cutoff::R) where {T<:Real, R<:Real}
     return maximum_weight_maximal_matching_lp(g, solver, cutoff_weights(w, cutoff))
 end
 
-function maximum_weight_maximal_matching_lp(g::Graph, solver::AbstractMathProgSolver, w::AbstractMatrix{T}) where {T<:Real}
+function maximum_weight_maximal_matching_lp(g::Graph, solver::JuMP.OptimizerFactory, w::AbstractMatrix{T}) where {T<:Real}
 # TODO support for graphs with zero degree nodes
 # TODO apply separately on each connected component
     bpmap = bipartite_map(g)
@@ -26,7 +26,7 @@ function maximum_weight_maximal_matching_lp(g::Graph, solver::AbstractMathProgSo
         end
     end
 
-    model = Model(solver=solver)
+    model = Model(solver)
     @variable(model, x[1:length(w)] >= 0)
 
     for i in v1
@@ -56,13 +56,14 @@ function maximum_weight_maximal_matching_lp(g::Graph, solver::AbstractMathProgSo
 
     @objective(model, Max, sum(w[src(e),dst(e)] * x[edgemap[e]] for e in keys(edgemap)))
 
-    status = solve(model)
-    status != :Optimal && error("JuMP solver failed to find optimal solution.")
-    sol = getvalue(x)
+    optimize!(model)
+    status = JuMP.termination_status(model)
+    status != MOI.OPTIMAL  && error("JuMP solver failed to find optimal solution.")
+    sol = JuMP.value.(x)
 
     all(Bool[s == 1 || s == 0 for s in sol]) || error("Found non-integer solution.")
 
-    cost = getobjectivevalue(model)
+    cost = JuMP.objective_value(model)
 
     mate = fill(-1, nv(g))
     for e in edges(g)

src/maximum_weight_matching.jl

@@ -22,10 +22,10 @@ Returns MatchingResult containing:
 function maximum_weight_matching end
 
 function maximum_weight_matching(g::Graph,
-          solver::AbstractMathProgSolver,
+          solver::JuMP.OptimizerFactory,
           w::AbstractMatrix{U} = default_weights(g)) where {U <:Real}
 
-    model = Model(solver = solver)
+    model = Model(with_optimizer(solver))
     n = nv(g)
     edge_list = collect(edges(g))
 
@@ -49,15 +49,16 @@ function maximum_weight_matching(g::Graph,
     @objective(model, Max, sum(x[e]*w[src(e),dst(e)] for e in edge_list))
 
     @constraint(model, c1[i=1:n], sum(x[Edge(minmax(i,j))] for j in neighbors(g,i)) <= 1)
-    status = solve(model)
-    solution = getvalue(x)
-    cost = getobjectivevalue(model)
-    ## TODO: add the option of returning the solve status as part of the MatchingResult type.
+    optimize!(model)
+    status = JuMP.termination_status(model)
+    status != MOI.OPTIMAL && error("JuMP solver failed to find optimal solution.")
+    solution = value.(x)
+    cost = objective_value(model)
     return MatchingResult(cost, dict_to_arr(n, solution, edge_list))
 end
 
 """ Returns an array of mates from a dictionary that maps edges to {0,1} """
-function dict_to_arr(n::Int64, solution::JuMP.JuMPArray{U,1,Tuple{Array{E,1}}}, edge_list::AbstractVector{E}) where {U<: Real, E<: Edge}
+function dict_to_arr(n::Int64, solution::JuMP.Containers.DenseAxisArray{U,1,Tuple{Array{E,1}}}, edge_list::AbstractVector{E}) where {U<: Real, E<: Edge}
   mate = fill(-1,n)
   for e in edge_list
     if solution[e] >= 1 - 1e-5 # Some tolerance to numerical approximations by the solver.

src/maximum_weight_maximal_matching.jl

@@ -16,8 +16,8 @@ function maximum_weight_maximal_matching(
     algorithm::LPAlgorithm, 
     solver = nothing
 ) where {T<:Real}
-    if ! isa(solver, AbstractMathProgSolver)
-        error("The keyword argument solver must be an AbstractMathProgSolver, as accepted by JuMP.")
+    if ! isa(solver, JuMP.OptimizerFactory)
+        error("The keyword argument solver must be an JuMP.OptimizerFactory, as accepted by JuMP.")
     end
 
     return maximum_weight_maximal_matching_lp(g, solver, w)
@@ -96,4 +96,4 @@ function cutoff_weights(w::AbstractMatrix{T}, cutoff::R) where {T<:Real, R<:Real
     wnew
 end
 
-@deprecate maximum_weight_maximal_matching(g::Graph, solver::AbstractMathProgSolver, w::AbstractMatrix{T}, cutoff::R) where {T<:Real, R<:Real} maximum_weight_maximal_matching(g, w, algorithm=LPAlgorithm(), cutoff=cutoff, solver=solver)
+@deprecate maximum_weight_maximal_matching(g::Graph, solver::JuMP.OptimizerFactory, w::AbstractMatrix{T}, cutoff::R) where {T<:Real, R<:Real} maximum_weight_maximal_matching(g, w, algorithm=LPAlgorithm(), cutoff=cutoff, solver=solver)

test/runtests.jl

@@ -1,28 +1,29 @@
 using LightGraphs
 using LightGraphsMatching
 using Test
-using Cbc: CbcSolver
+using Cbc
+using JuMP
 using LinearAlgebra: I
 
 @testset "LightGraphsMatching" begin
 
 @testset "maximum_weight_matching" begin
-    g = CompleteGraph(3)
+    g = complete_graph(3)
     w = [
          1 2 1
          1 1 1
          3 1 1
         ]
-    match = maximum_weight_matching(g, CbcSolver(), w)
+    match = maximum_weight_matching(g, with_optimizer(Cbc.Optimizer, logLevel=0), w)
     @test match.mate[1] == 3
     @test match.weight ≈ 3
 
-    g = CompleteGraph(3)
+    g = complete_graph(3)
     w = zeros(3,3)
     w[1,2] = 1
     w[3,2] = 1
     w[1,3] = 1
-    match = maximum_weight_matching(g,CbcSolver(),w)
+    match = maximum_weight_matching(g,with_optimizer(Cbc.Optimizer, logLevel=0),w)
     @test match.weight ≈ 1
 
 
@@ -36,7 +37,7 @@ using LinearAlgebra: I
     w[1,4] = 3
     w[2,4] = 1
 
-    match = maximum_weight_matching(g,CbcSolver(),w)
+    match = maximum_weight_matching(g,with_optimizer(Cbc.Optimizer, logLevel=0),w)
     @test match.weight ≈ 3
     @test match.mate[1] == 4
     @test match.mate[2] == -1
@@ -48,7 +49,7 @@ using LinearAlgebra: I
     add_edge!(g, 2,3)
     add_edge!(g, 3,1)
     add_edge!(g, 3,4)
-    match = maximum_weight_matching(g,CbcSolver())
+    match = maximum_weight_matching(g,with_optimizer(Cbc.Optimizer, logLevel=0))
     @test match.weight ≈ 2
     @test match.mate[1] == 2
     @test match.mate[2] == 1
@@ -61,7 +62,7 @@ using LinearAlgebra: I
     w[1,3] = 1
     w[3,4] = 1
 
-    match = maximum_weight_matching(g,CbcSolver(), w)
+    match = maximum_weight_matching(g,with_optimizer(Cbc.Optimizer, logLevel=0), w)
     @test match.weight ≈ 2
     @test match.mate[1] == 2
     @test match.mate[2] == 1
@@ -74,7 +75,7 @@ using LinearAlgebra: I
     w[1,3] = 5
     w[3,4] = 1
 
-    match = maximum_weight_matching(g,CbcSolver(),w)
+    match = maximum_weight_matching(g,with_optimizer(Cbc.Optimizer, logLevel=0),w)
     @test match.weight ≈ 5
     @test match.mate[1] == 3
     @test match.mate[2] == -1
@@ -85,56 +86,56 @@ end
 
 @testset "maximum_weight_maximal_matching" begin
 
-    g = CompleteBipartiteGraph(2,2)
+    g = complete_bipartite_graph(2,2)
     w = zeros(4,4)
     w[1,3] = 10.
     w[1,4] = 1.
     w[2,3] = 2.
     w[2,4] = 11.
-    match = maximum_weight_maximal_matching(g, w, algorithm=LPAlgorithm(), solver=CbcSolver())
+    match = maximum_weight_maximal_matching(g, w, algorithm=LPAlgorithm(), solver=with_optimizer(Cbc.Optimizer, logLevel=0))
     @test match.weight ≈ 21
     @test match.mate[1] == 3
     @test match.mate[3] == 1
     @test match.mate[2] == 4
     @test match.mate[4] == 2
 
-    g =CompleteBipartiteGraph(2,4)
+    g =complete_bipartite_graph(2,4)
     w =zeros(6,6)
     w[1,3] = 10
     w[1,4] = 0.5
     w[2,3] = 11
     w[2,4] = 1
-    match = maximum_weight_maximal_matching(g, w, algorithm=LPAlgorithm(), solver=CbcSolver())
+    match = maximum_weight_maximal_matching(g, w, algorithm=LPAlgorithm(), solver=with_optimizer(Cbc.Optimizer, logLevel=0))
     @test match.weight ≈ 11.5
     @test match.mate[1] == 4
     @test match.mate[4] == 1
     @test match.mate[2] == 3
     @test match.mate[3] == 2
 
-    g =CompleteBipartiteGraph(2,6)
+    g =complete_bipartite_graph(2,6)
     w =zeros(8,8)
     w[1,3] = 10
     w[1,4] = 0.5
     w[2,3] = 11
     w[2,4] = 1
     w[2,5] = -1
     w[2,6] = -1
-    match = maximum_weight_maximal_matching(g, w, algorithm=LPAlgorithm(), solver=CbcSolver(), cutoff=0)
+    match = maximum_weight_maximal_matching(g, w, algorithm=LPAlgorithm(), solver=with_optimizer(Cbc.Optimizer, logLevel=0), cutoff=0)
     @test match.weight ≈ 11.5
     @test match.mate[1] == 4
     @test match.mate[4] == 1
     @test match.mate[2] == 3
     @test match.mate[3] == 2
 
-    g =CompleteBipartiteGraph(4,2)
+    g =complete_bipartite_graph(4,2)
     w = zeros(6,6)
     w[3,5] = 10
     w[3,6] = 0.5
     w[2,5] = 11
     w[1,6] = 1
     w[1,5] = -1
 
-    match = maximum_weight_maximal_matching(g, w, algorithm=LPAlgorithm(), solver=CbcSolver(), cutoff=0)
+    match = maximum_weight_maximal_matching(g, w, algorithm=LPAlgorithm(), solver=with_optimizer(Cbc.Optimizer, logLevel=0), cutoff=0)
     @test match.weight ≈ 12
     @test match.mate[1] == 6
     @test match.mate[2] == 5
@@ -144,7 +145,7 @@ end
     @test match.mate[6] == 1
 
 
-    g = CompleteBipartiteGraph(2, 2)
+    g = complete_bipartite_graph(2, 2)
     w = zeros(4, 4)
     w[1, 3] = 10.
     w[1, 4] = 1.
@@ -157,12 +158,12 @@ end
     @test match.mate[2] == 4
     @test match.mate[4] == 2
 
-    g = CompleteGraph(3)
+    g = complete_graph(3)
     w = zeros(3, 3)
     @test ! is_bipartite(g)
     @test_throws ErrorException maximum_weight_maximal_matching(g, w, algorithm=HungarianAlgorithm())
 
-    g = CompleteBipartiteGraph(2, 4)
+    g = complete_bipartite_graph(2, 4)
     w = zeros(6, 6)
     w[1, 3] = 10
     w[1, 4] = 0.5
@@ -201,7 +202,7 @@ end
            Edge(3,4)=>100,
            Edge(2,4)=>1000)
 
-    g = CompleteGraph(4)
+    g = complete_graph(4)
     match = minimum_weight_perfect_matching(g, w)
     @test match.mate[1] == 2
     @test match.mate[2] == 1
@@ -216,15 +217,15 @@ end
              Edge(3, 4) => 1000,
              Edge(2, 4) => 1000
             )
-    g = CompleteGraph(4)
+    g = complete_graph(4)
     match = minimum_weight_perfect_matching(g, w)
     @test match.mate[1] == 3
     @test match.mate[2] == 4
     @test match.mate[3] == 1
     @test match.mate[4] == 2
     @test match.weight ≈ 1400
 
-    g =CompleteBipartiteGraph(2,2)
+    g =complete_bipartite_graph(2,2)
     w =Dict{Edge,Float64}()
     w[Edge(1,3)] = -10
     w[Edge(1,4)] = -0.5
@@ -239,7 +240,7 @@ end
     @test match.weight ≈ -11.5
 
 
-    g = CompleteGraph(4)
+    g = complete_graph(4)
     w = Dict{Edge,Float64}()
     w[Edge(1,3)] = 10
     w[Edge(1,4)] = 0.5