fix conflicts

Author: matbesancon

Project.toml

@@ -1,7 +1,7 @@
 name = "LightGraphsFlows"
 uuid = "2f5eb75a-258c-59e0-affc-f41c55f75335"
 authors = ["Mathieu Besançon <mathieu.besancon@gmail.com>"]
-version = "0.3.1"
+version = "0.4.0"
 
 [deps]
 JuMP = "4076af6c-e467-56ae-b986-b466b2749572"
@@ -12,6 +12,7 @@ SimpleTraits = "699a6c99-e7fa-54fc-8d76-47d257e15c1d"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 
 [compat]
+JuMP = "0.20"
 LightGraphs = "1"
 SimpleTraits = "0.9"
 julia = "1"

README.md

@@ -81,7 +81,10 @@ Mincost flow is solving a linear optimization problem and thus requires a LP sol
 defined by [MathProgBase.jl](http://mathprogbasejl.readthedocs.io).
 
 ```julia
-using Clp: ClpSolver
+using SparseArrays: spzeros
+import Clp
+using JuMP: with_optimizer
+
 g = lg.DiGraph(6)
 lg.add_edge!(g, 5, 1)
 lg.add_edge!(g, 5, 2)
@@ -91,16 +94,17 @@ lg.add_edge!(g, 1, 3)
 lg.add_edge!(g, 1, 4)
 lg.add_edge!(g, 2, 3)
 lg.add_edge!(g, 2, 4)
-w = zeros(6,6)
-w[1,3] = 10.
-w[1,4] = 5.
-w[2,3] = 2.
-w[2,4] = 2.
+cost = zeros(6,6)
+cost[1,3] = 10.
+cost[1,4] = 5.
+cost[2,3] = 2.
+cost[2,4] = 2.
 # v2 -> sink have demand of one
 demand = spzeros(6,6)
 demand[3,6] = 1
 demand[4,6] = 1
+node_demand = spzeros(6)
 capacity = ones(6,6)
 
-flow = mincost_flow(g, capacity, demand, w, ClpSolver(), 5, 6)
+flow = mincost_flow(g, node_demand, capacity, cost, with_optimizer(Clp.Optimizer), edge_demand=demand, source_nodes=[5], sink_nodes=[6])
 ```

REQUIRE

@@ -0,0 +1,4 @@
+[deps]
+Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
+LightGraphs = "093fc24a-ae57-5d10-9952-331d41423f4d"
+LightGraphsFlows = "2f5eb75a-258c-59e0-affc-f41c55f75335"

docs/Project.toml

@@ -1,6 +1,6 @@
 using Documenter
 using LightGraphsFlows
-import LightGraphs
+using LightGraphs
 const lg = LightGraphs
 
 makedocs(
@@ -20,6 +20,5 @@ deploydocs(
     deps        = nothing,
     make        = nothing,
     repo        = "github.com/JuliaGraphs/LightGraphsFlows.jl.git",
-    target      = "build",
-    osname      = "linux"
+    versions = ["stable" => "v^", "v#.#", "dev" => "master"],
 )

docs/make.jl

@@ -18,6 +18,7 @@ Order = [:function, :type]
 This is the documentation page for `LightGraphsFlows`. In all pages, we assume
 LightGraphsFlows has been imported into scope and that LightGraphs is 
 available with the alias `lg`:
+
 ```julia
 using LightGraphsFlows
 import LightGraphs

docs/src/index.md

@@ -1,12 +1,12 @@
 module LightGraphsFlows
 
-import LightGraphs
+using LightGraphs
 const lg = LightGraphs
+
 using SimpleTraits: @traitfn, @traitimpl
 import SimpleTraits
 
-using MathProgBase.HighLevelInterface: linprog
-using MathProgBase.SolverInterface: AbstractMathProgSolver
+using JuMP
 
 using SparseArrays: spzeros, sparse, sparsevec
 using Markdown: @doc_str
@@ -28,5 +28,4 @@ export
 maximum_flow, EdmondsKarpAlgorithm, DinicAlgorithm, BoykovKolmogorovAlgorithm, PushRelabelAlgorithm,
 multiroute_flow, KishimotoAlgorithm, ExtendedMultirouteFlowAlgorithm, mincost_flow
 
-
 end

src/LightGraphsFlows.jl

@@ -1,122 +1,119 @@
 """
-    mincost_flow(graph, node_demand, edge_capacity, edge_cost, solver,<keyword arguments>)
+    function mincost_flow(g::AbstractGraph,
+    		node_demand::AbstractVector,
+    		edge_capacity::AbstractMatrix,
+    		edge_cost::AbstractMatrix,
+    		optimizer;
+    		edge_demand::Union{Nothing,AbstractMatrix} = nothing,
+    		source_nodes = (),
+    		sink_nodes = ()
+    		)
 
-Find a flow satisfying the `node_demand` at each node and `edge_capacity` constraints for each edge
-while minimizing the `sum(edge_cost.*flow)`.
+Find a flow over a directed graph `g` satisfying the `node_demand` at each
+node and `edge_capacity` constraints for each edge while minimizing `dot(edge_cost, flow)`.
 
--`node_demand` is a vector of nodal values, which should be positive for sources and
- negative at sink nodes, any node with zero demand is a transport node
+Returns a sparse flow matrix, flow[i,j] corresponds to the flow on the (i,j) arc.
 
-- The problem can be seen as a linear programming problem and uses a LP
-solver under the hood. We use Clp in the examples and tests.
-
-Returns a flow matrix, flow[i,j] corresponds to the flow on the (i,j) arc.
 # Arguments
-- `edge_demand::AbstractMatrix`: demand a minimum flow for a given edge.
-- `edge_demand_exact=true`: changes the capacity of a non zero edge to the demanded value
-- `source_nodes::AbstractVector` Sources at which the nodal netflow is allowed to be greater than nodal demand **
-- `sink_nodes::AbstractVector` Sinks at which the nodal netflow is allowed to be less than nodal demand **
-   ** source_nodes & sink_nodes are only needed when nodal flow are not explictly set in node_demand
+
+- `g` is a directed `LightGraphs.AbstractGraph`.
+-`node_demand` is a vector of nodal demand values, which should be negative for sources,
+positive for sink nodes, and zero for all other nodes.
+- `edge_capacity::AbstractMatrix` sets an upper bound on the flow of each arc.
+- `edge_cost::AbstractMatrix` the cost per unit of flow on each arc.
+- `optimizer` is an optimizer factory as defined in JuMP, passed at the construction of the `JuMP.Model`.
+
+# Keyword arguments
+
+- `edge_demand::Union{Nothing,AbstractMatrix}`: require a minimum flow for edges, or nothing.
+- `source_nodes` Collection of sources at which the nodal netflow is allowed to be greater than nodal demand, defaults to an empty tuple.
+- `sink_nodes` Collection of sinks at which the nodal netflow is allowed to be less than nodal demand, defaults to an empty tuple.
+
+`source_nodes` & `sink_nodes` are only needed when nodal flow are not explictly set in node_demand
 
 ### Usage Example:
 
 ```julia
-julia> using Clp: ClpSolver # use your favorite LP solver here
-julia> g = lg.DiGraph(6) # Create a flow-graph
-julia> lg.add_edge!(g, 5, 1)
-julia> lg.add_edge!(g, 5, 2)
-julia> lg.add_edge!(g, 3, 6)
-julia> lg.add_edge!(g, 4, 6)
-julia> lg.add_edge!(g, 1, 3)
-julia> lg.add_edge!(g, 1, 4)
-julia> lg.add_edge!(g, 2, 3)
-julia> lg.add_edge!(g, 2, 4)
-julia> w = zeros(6,6)
-julia> w[1,3] = 10.
-julia> w[1,4] = 5.
-julia> w[2,3] = 2.
-julia> w[2,4] = 2.
+julia> import LightGraphs
+julia> const LG = LightGraphs
+julia> using LightGraphsFlows: mincost_flow
+julia> import Clp # use your favorite LP solver here
+julia> import JuMP
+julia> using SparseArrays: spzeros
+julia> g = LG.DiGraph(6) # Create a flow-graph
+julia> LG.add_edge!(g, 5, 1)
+julia> LG.add_edge!(g, 5, 2)
+julia> LG.add_edge!(g, 3, 6)
+julia> LG.add_edge!(g, 4, 6)
+julia> LG.add_edge!(g, 1, 3)
+julia> LG.add_edge!(g, 1, 4)
+julia> LG.add_edge!(g, 2, 3)
+julia> LG.add_edge!(g, 2, 4)
+julia> cost = zeros(6,6)
+julia> cost[1,3] = 10
+julia> cost[1,4] = 5
+julia> cost[2,3] = 2
+julia> cost[2,4] = 2
 julia> demand = spzeros(6)
-julia> demand[5] = 2
-julia> demand[6] = -2
+julia> demand[5] = -2
+julia> demand[6] = 2
 julia> capacity = ones(6,6)
-julia> flow = mincost_flow(g, demand, capacity, w, ClpSolver())
+julia> flow = mincost_flow(g, demand, capacity, cost, JuMP.with_optimizer(Clp.Optimizer))
 ```
 """
+function mincost_flow end
 
-
-function mincost_flow(g::lg.DiGraph,
+@traitfn function mincost_flow(g::AG::lg.IsDirected,
 		node_demand::AbstractVector,
 		edge_capacity::AbstractMatrix,
 		edge_cost::AbstractMatrix,
-		solver::AbstractMathProgSolver;
+		optimizer;
 		edge_demand::Union{Nothing,AbstractMatrix} = nothing,
-		edge_demand_exact::Bool = false, #If true changes capacity of that node to the value in edge demand
-		source_nodes::AbstractVector{<:Integer} = Vector{Integer}(), #Source nodes at which to allow a netflow greater than nodal demand
-		sink_nodes::AbstractVector{<:Integer} = Vector{Integer}()	 #Sink nodes at which to allow a netflow less than nodal demand
-		)
-	T = eltype(g)
-	VT = promote_type(eltype(edge_capacity),eltype(node_demand),eltype(edge_cost))
-
-	nv = lg.nv(g)
-	ne = lg.ne(g)
-	b = Vector{VT}(undef,nv)
-	AI = Vector{T}(undef,2*ne)
-	AJ = Vector{T}(undef,2*ne)
-	AV = Vector{VT}(undef,2*ne)
-	edge_costs = Vector{VT}(undef,ne)
-	upperbounds = Vector{VT}(undef,ne)
-	lowerbounds = Vector{VT}(undef,ne)
-	sense = ['=' for _ in 1:nv]
-
-	has_edge_demand= edge_demand !== nothing
-
-	inds = [-1,0]
-	for (n,e) in enumerate(lg.edges(g))
-		inds .+= 2
-		s = lg.src(e)
-		t = lg.dst(e)
-		AI[inds] = [s,t] #the node index
-		AJ[inds] = [n,n]  #the edge index
-		AV[inds] = [1,-1]
-		upperbounds[n] = edge_capacity[s,t]
-		lowerbounds[n] = has_edge_demand ? edge_demand[s,t] : zero(VT)
-		if edge_demand_exact && has_edge_demand && lowerbounds[n] != 0
-			upperbounds[n] = lowerbounds[n]
-		end
-
-		edge_costs[n] = edge_cost[s,t]
-	end
-	for n = 1:nv
-		b[n] = node_demand[n]
-	end
-
-	for n in source_nodes
-		sense[n] = '>'
+		source_nodes = (), # Source nodes at which to allow a netflow greater than nodal demand
+		sink_nodes = ()	   # Sink nodes at which to allow a netflow less than nodal demand
+		) where {AG <: lg.AbstractGraph}
+
+	m = JuMP.Model(optimizer)
+	vtxs = vertices(g)
+
+	source_nodes = [v for v in vtxs if v in source_nodes || node_demand[v] < 0]
+	sink_nodes = [v for v in vtxs if v in sink_nodes || node_demand[v] > 0]
+
+	@variable(m, 0 <= f[i=vtxs,j=vtxs; (i,j) in lg.edges(g)] <= edge_capacity[i, j])
+	@objective(m, Min, sum(f[src(e),dst(e)] * edge_cost[src(e), dst(e)] for e in lg.edges(g)))
+
+	for v in lg.vertices(g)
+	    if v in source_nodes
+            @constraint(m,
+                sum(f[v, vout] for vout in outneighbors(g, v)) - sum(f[vin, v] for vin in lg.inneighbors(g, v)) >= -node_demand[v]
+            )
+	    elseif v in sink_nodes
+            @constraint(m,
+                sum(f[vin, v] for vin in lg.inneighbors(g, v)) - sum(f[v, vout] for vout in outneighbors(g, v)) >= node_demand[v]
+            )
+	    else
+            @constraint(m,
+                sum(f[vin, v] for vin in lg.inneighbors(g, v)) == sum(f[v, vout] for vout in outneighbors(g, v))
+            )
+        end
 	end
-	for n in sink_nodes
-		sense[n] = '<'
-	end
-
 
-	A = sparse(AI,AJ,AV,nv,ne)
-	# return (edge_costs, A, sense, b, lowerbounds, upperbounds, solver)
-	sol = linprog(edge_costs, A, sense, b, lowerbounds, upperbounds, solver)
-	sol_sparse = sparse(view(AI,1:2:2*ne),view(AI,2:2:2*ne),sol.sol,nv,nv)
-	return sol_sparse
+    if edge_demand isa AbstractMatrix
+        for e in lg.edges(g)
+            (i,j) = Tuple(e)
+            JuMP.set_lower_bound(f[i,j], edge_demand[i,j])
+        end
+    end
+    optimize!(m)
+    ts = termination_status(m)
+    result_flow = spzeros(nv(g), nv(g))
+    if ts != MOI.OPTIMAL
+        @warn "Problem does not have an optimal solution, status: $(ts)"
+        return result_flow
+    end
+    for e in lg.edges(g)
+        (i,j) = Tuple(e)
+        result_flow[i,j] = JuMP.value(f[i,j])
+    end
+    return result_flow
 end
-
-@deprecate mincost_flow(g::lg.DiGraph,
-		capacity::AbstractMatrix,
-		demand::AbstractMatrix,
-		cost::AbstractMatrix,
-		solver::AbstractMathProgSolver,
-		source::Int, # if source and/or sink omitted or not in nodes, circulation problem
-		sink::Int)  mincost_flow(g,spzeros(lg.nv(g)),capacity,cost,solver,edge_demand=demand,source_nodes=[source],sink_nodes=[sink])
-
-@deprecate mincost_flow(g::lg.DiGraph,
-		capacity::AbstractMatrix,
-		demand::AbstractMatrix,
-		cost::AbstractMatrix,
-		solver::AbstractMathProgSolver
-		)  mincost_flow(g,spzeros(lg.nv(g)),capacity,cost,solver,edge_demand=demand)