relocate shared network functions in a separate file

Author: jbytecode

src/OperationsResearchModels.jl

@@ -19,6 +19,7 @@ include("transportation.jl")
 include("assignment.jl")
 include("shortestpath.jl")
 include("maximumflow.jl")
+include("minimumcostflow.jl")
 include("game.jl")
 include("mst.jl")
 include("pmedian.jl")
@@ -35,6 +36,7 @@ import .Transportation
 import .Assignment
 import .ShortestPath
 import .MaximumFlow
+import .MinimumCostFlow
 import .Game
 import .MinimumSpanningTree
 import .PMedian
@@ -59,7 +61,7 @@ import .ShortestPath: ShortestPathResult, ShortestPathProblem
 
 import .Network: Connection, nodes
 import .MaximumFlow: MaximumFlowResult, MaximumFlowProblem
-import .MaximumFlow: MinimumCostFlowProblem, MinimumCostFlowResult
+import .MinimumCostFlow: MinimumCostFlowProblem, MinimumCostFlowResult
 import .Assignment: AssignmentProblem, AssignmentResult
 import .Game: game, GameResult, game_solver
 import .MinimumSpanningTree: hasloop, MstResult, MstProblem

src/maximumflow.jl

@@ -1,13 +1,13 @@
 module MaximumFlow
 
-using ..Network
+import ..Network: Connection, nodes, start, finish, hassameorder, leftexpressions, rightexpressions
 
 using JuMP, HiGHS
 import ..OperationsResearchModels: solve
 
 
 export MaximumFlowProblem, MaximumFlowResult
-export MinimumCostFlowProblem, MinimumCostFlowResult
+
 
 
 struct MaximumFlowResult
@@ -19,66 +19,10 @@ struct MaximumFlowProblem
     connections::Vector{Connection}
 end
 
-struct MinimumCostFlowProblem
-    connections::Vector{Connection}
-    costs::Vector{Connection}
-end
 
-struct MinimumCostFlowResult 
-    path::Vector{Connection}
-    cost::Float64
-end 
 
 
-function leftexpressions(x::Matrix{JuMP.VariableRef}, node::Int64, nodes::Vector{Connection}, model)
-    lst = []
-    for conn in nodes
-        if conn.to == node
-            push!(lst, conn)
-        end
-    end
-    if length(lst) == 0
-        return :f
-    end
-    expr = @expression(model, 0)
-    for i = eachindex(lst)
-        expr += x[lst[i].from, lst[i].to]
-    end
-    return expr
-end
 
-function rightexpressions(x::Matrix{JuMP.VariableRef}, node::Int64, nodes::Vector{Connection}, model)
-    lst = []
-    for conn in nodes
-        if conn.from == node
-            push!(lst, conn)
-        end
-    end
-    if length(lst) == 0
-        return :f
-    end
-    expr = @expression(model, 0)
-    for i = eachindex(lst)
-        expr += x[lst[i].from, lst[i].to]
-    end
-    return expr
-end
-
-
-function hassameorder(a::Vector{Connection}, b::Vector{Connection})::Bool
-
-    if length(a) != length(b)
-        return false
-    end
-
-    for i = 1:length(a)
-        if a[i].from != b[i].from || a[i].to != b[i].to
-            return false
-        end
-    end
-
-    return true
-end
 
 """
 
@@ -182,101 +126,6 @@ end
 
 
 
-"""
-    solve(problem, flow)
-
-# Description
-
-This function solves the Minimum Cost Flow problem given a flow value.
-
-# Arguments
-
-- `problem::MinimumCostFlowProblem`: The problem in type of MinimumCostFlowProblem
-- `flow::Float64`: The flow value to be used in the problem.
-
-
-"""
-function solve(problem::MinimumCostFlowProblem, flow::Float64)::MinimumCostFlowResult
-    cns = problem.connections
-    costs = problem.costs
-
-    if !hassameorder(cns, costs)
-        throw(ArgumentError("Connections and costs must have the same order."))
-    end
-
-    model = Model(HiGHS.Optimizer)
-    MOI.set(model, MOI.Silent(), true)
-
-    mynodes = nodes(cns)
-    n = length(mynodes)
-
-    startnode = start(cns)
-    finishnode = finish(cns)
-
-    # Variables 
-    @variable(model, x[1:n, 1:n] .>= 0)
-
-    # Objective Function
-    @objective(model, Min, sum(x[conn.from, conn.to] * conn.value for conn in costs))
-
-    # Constraints 
-    for nextnode in mynodes
-        leftexpr = leftexpressions(x, nextnode, cns, model)
-        rightexpr = rightexpressions(x, nextnode, cns, model)
-        if leftexpr == :f
-            @constraint(model, rightexpr == flow)
-        elseif rightexpr == :f
-            @constraint(model, leftexpr == flow)
-        else
-            @constraint(model, leftexpr - rightexpr == 0)
-        end
-    end
-
-    for nd in cns
-        @constraint(model, x[nd.from, nd.to] <= nd.value)
-    end
-
-    optimize!(model)
-
-    xs = value.(x)
-    cost = JuMP.objective_value(model)
-    solutionnodes = []
-    for i = 1:n
-        for j = 1:n
-            if xs[i, j] > 0
-                push!(solutionnodes, Connection(i, j, xs[i, j]))
-            end
-        end
-    end
-
-    return MinimumCostFlowResult(solutionnodes, cost)
-end 
-
-
-"""
-    solve(problem)
-
-# Description
-
-This function solves the Minimum Cost Flow problem by first solving the Maximum Flow problem and 
-then using the flow value to solve the Minimum Cost Flow problem.
-
-# Arguments
-
-- `problem::MinimumCostFlowProblem`: The problem in type of MinimumCostFlowProblem
-
-"""
-function solve(problem::MinimumCostFlowProblem)::MinimumCostFlowResult
-
-    maximumflowproblem = MaximumFlowProblem(problem.connections)
-
-    maximumflowresult = solve(maximumflowproblem)
-
-    f = maximumflowresult.flow
 
-    result::MinimumCostFlowResult = solve(problem, f)
-    
-    return result
-end 
 
 end # end of module

src/minimumcostflow.jl

@@ -0,0 +1,121 @@
+module MinimumCostFlow
+
+using JuMP, HiGHS
+import ..OperationsResearchModels: solve
+
+import ..Network: Connection, nodes, start, finish, hassameorder, leftexpressions, rightexpressions
+import ..MaximumFlow: MaximumFlowProblem, MaximumFlowResult
+
+export MinimumCostFlowProblem, MinimumCostFlowResult
+
+struct MinimumCostFlowProblem
+    connections::Vector{Connection}
+    costs::Vector{Connection}
+end
+
+struct MinimumCostFlowResult 
+    path::Vector{Connection}
+    cost::Float64
+end 
+
+
+
+"""
+    solve(problem, flow)
+
+# Description
+
+This function solves the Minimum Cost Flow problem given a flow value.
+
+# Arguments
+
+- `problem::MinimumCostFlowProblem`: The problem in type of MinimumCostFlowProblem
+- `flow::Float64`: The flow value to be used in the problem.
+
+
+"""
+function solve(problem::MinimumCostFlowProblem, flow::Float64)::MinimumCostFlowResult
+    cns = problem.connections
+    costs = problem.costs
+
+    if !hassameorder(cns, costs)
+        throw(ArgumentError("Connections and costs must have the same order."))
+    end
+
+    model = Model(HiGHS.Optimizer)
+    MOI.set(model, MOI.Silent(), true)
+
+    mynodes = nodes(cns)
+    n = length(mynodes)
+
+    startnode = start(cns)
+    finishnode = finish(cns)
+
+    # Variables 
+    @variable(model, x[1:n, 1:n] .>= 0)
+
+    # Objective Function
+    @objective(model, Min, sum(x[conn.from, conn.to] * conn.value for conn in costs))
+
+    # Constraints 
+    for nextnode in mynodes
+        leftexpr = leftexpressions(x, nextnode, cns, model)
+        rightexpr = rightexpressions(x, nextnode, cns, model)
+        if leftexpr == :f
+            @constraint(model, rightexpr == flow)
+        elseif rightexpr == :f
+            @constraint(model, leftexpr == flow)
+        else
+            @constraint(model, leftexpr - rightexpr == 0)
+        end
+    end
+
+    for nd in cns
+        @constraint(model, x[nd.from, nd.to] <= nd.value)
+    end
+
+    optimize!(model)
+
+    xs = value.(x)
+    cost = JuMP.objective_value(model)
+    solutionnodes = []
+    for i = 1:n
+        for j = 1:n
+            if xs[i, j] > 0
+                push!(solutionnodes, Connection(i, j, xs[i, j]))
+            end
+        end
+    end
+
+    return MinimumCostFlowResult(solutionnodes, cost)
+end 
+
+
+"""
+    solve(problem)
+
+# Description
+
+This function solves the Minimum Cost Flow problem by first solving the Maximum Flow problem and 
+then using the flow value to solve the Minimum Cost Flow problem.
+
+# Arguments
+
+- `problem::MinimumCostFlowProblem`: The problem in type of MinimumCostFlowProblem
+
+"""
+function solve(problem::MinimumCostFlowProblem)::MinimumCostFlowResult
+
+    maximumflowproblem = MaximumFlowProblem(problem.connections)
+
+    maximumflowresult = solve(maximumflowproblem)
+
+    f = maximumflowresult.flow
+
+    result::MinimumCostFlowResult = solve(problem, f)
+    
+    return result
+end 
+
+
+end # end of module MinimumCostFlow