Merge pull request #10 from Robbybp/subtype-conref

Author: Robbybp

src/identify_variables.jl

@@ -61,8 +61,7 @@ julia> display(vars)
 
 """
 function identify_unique_variables(
-    constraints::Vector,
-    # FIXME: Couldn't get this working with Vector{ConstraintRef}...
+    constraints::Vector{<:JuMP.ConstraintRef},
 )::Vector{JuMP.VariableRef}
     variables = Vector{JuMP.VariableRef}()
     for con in constraints

src/incidence_graph.jl

@@ -27,6 +27,15 @@ import JuMP
 
 import JuMPIn: get_equality_constraints, identify_unique_variables
 
+const GraphDataTuple = Tuple{
+    # (A, B, E) describing the bipartite graph
+    Tuple{Vector{Int}, Vector{Int}, Vector{Tuple{Int, Int}}},
+    # Map from constraints to nodes (in A)
+    Dict{JuMP.ConstraintRef, Int},
+    # Map from variables to nodes (in B)
+    Dict{JuMP.VariableRef, Int},
+}
+
 """
     get_bipartite_incidence_graph(model, include_inequality = false)
 
@@ -85,7 +94,7 @@ regardless of which variables participate in the constraints.
 function get_bipartite_incidence_graph(
     model::JuMP.Model;
     include_inequality::Bool = false,
-)
+)::GraphDataTuple
     if include_inequality
         # Note that this may generate some constraints that are incompatible
         # with downstream function calls (e.g. constraints involving vector
@@ -109,17 +118,19 @@ function get_bipartite_incidence_graph(
     return get_bipartite_incidence_graph(constraints)
 end
 
-function get_bipartite_incidence_graph(constraints::Vector{JuMP.ConstraintRef})
+function get_bipartite_incidence_graph(
+    constraints::Vector{<:JuMP.ConstraintRef}
+)::GraphDataTuple
     variables = identify_unique_variables(constraints)
     # We could build up a variable-index map dynamically to get the incidence
     # in a single loop over the constraints, but this is easier to implement.
     return get_bipartite_incidence_graph(constraints, variables)
 end
 
 function get_bipartite_incidence_graph(
-    constraints::Vector{JuMP.ConstraintRef},
+    constraints::Vector{<:JuMP.ConstraintRef},
     variables::Vector{JuMP.VariableRef},
-)
+)::GraphDataTuple
     ncon = length(constraints)
     nvar = length(variables)
     # Note the convention we apply: Constraints take the first 1:ncon

src/interface.jl

@@ -24,7 +24,7 @@ A JuMP interface to the algorithms implemented by JuMPIn
 
 import JuMP
 
-import JuMPIn: get_bipartite_incidence_graph, maximum_matching
+import JuMPIn: get_bipartite_incidence_graph, maximum_matching, GraphDataTuple
 
 import Graphs as gjl
 import BipartiteMatching as bpm
@@ -101,7 +101,7 @@ end
 
 
 IncidenceGraphInterface(
-    args::Tuple{Tuple, Dict, Dict}
+    args::GraphDataTuple
 ) = IncidenceGraphInterface(
     _tuple_to_graphs_jl(args[1]),
     args[2],
@@ -119,7 +119,7 @@ IncidenceGraphInterface(
 
 
 IncidenceGraphInterface(
-    constraints::Vector{JuMP.ConstraintRef},
+    constraints::Vector{<:JuMP.ConstraintRef},
     variables::Vector{JuMP.VariableRef},
 ) = IncidenceGraphInterface(
     get_bipartite_incidence_graph(constraints, variables)
@@ -138,7 +138,7 @@ Return the variables adjacent to a constraint in an incidence graph.
 function get_adjacent(
     igraph::IncidenceGraphInterface,
     constraint::JuMP.ConstraintRef,
-)
+)::Vector{JuMP.VariableRef}
     con_node = igraph._con_node_map[constraint]
     var_nodes = gjl.neighbors(igraph._graph, con_node)
     variables = [igraph._nodes[n] for n in var_nodes]
@@ -165,7 +165,7 @@ julia> @NLconstraint(m, eq_2, v[1]*v[2]^3 == 2);
 julia> igraph = ji.IncidenceGraphInterface(m);
 julia> adj_cons = ji.get_adjacent(igraph, v[1]);
 julia> display(adj_cons)
-2-element Vector{ConstraintRef{Model, C, ScalarShape} where C}:
+2-element Vector{ConstraintRef}:
  eq_1 : v[1] + v[3] = 1.0
  v[1] * v[2] ^ 3.0 - 2.0 = 0
 ```
@@ -174,7 +174,7 @@ julia> display(adj_cons)
 function get_adjacent(
     igraph::IncidenceGraphInterface,
     variable::JuMP.VariableRef,
-)
+)::Vector{JuMP.ConstraintRef}
     var_node = igraph._var_node_map[variable]
     con_nodes = gjl.neighbors(igraph._graph, var_node)
     constraints = [igraph._nodes[n] for n in con_nodes]
@@ -200,7 +200,7 @@ julia> @NLconstraint(m, eq_2, v[1]*v[2]^3 == 2);
 julia> igraph = ji.IncidenceGraphInterface(m);
 julia> matching = ji.maximum_matching(igraph);
 julia> display(matching)
-Dict{ConstraintRef{Model, C, ScalarShape} where C, VariableRef} with 2 entries:
+Dict{ConstraintRef, VariableRef} with 2 entries:
   v[1] * v[2] ^ 3.0 - 2.0 = 0 => v[2]
   eq_1 : v[1] + v[3] = 1.0 => v[1]
 ```
@@ -220,13 +220,32 @@ end
 
 
 function maximum_matching(
-    constraints::Vector{JuMP.ConstraintRef},
+    constraints::Vector{<:JuMP.ConstraintRef},
     variables::Vector{JuMP.VariableRef},
 )::Dict{JuMP.ConstraintRef, JuMP.VariableRef}
     igraph = IncidenceGraphInterface(constraints, variables)
     return maximum_matching(igraph)
 end
 
+const DMConPartition = NamedTuple{
+    (:underconstrained, :square, :overconstrained, :unmatched),
+    Tuple{
+        Vector{JuMP.ConstraintRef},
+        Vector{JuMP.ConstraintRef},
+        Vector{JuMP.ConstraintRef},
+        Vector{JuMP.ConstraintRef},
+    },
+}
+
+const DMVarPartition = NamedTuple{
+    (:unmatched, :underconstrained, :square, :overconstrained),
+    Tuple{
+        Vector{JuMP.VariableRef},
+        Vector{JuMP.VariableRef},
+        Vector{JuMP.VariableRef},
+        Vector{JuMP.VariableRef},
+    },
+}
 
 """
     dulmage_mendelsohn(igraph::IncidenceGraphInterface)
@@ -294,21 +313,23 @@ julia> display(var_dmp.underconstrained)
  v[1]
  v[2]
 julia> display(con_dmp.underconstrained)
-2-element Vector{ConstraintRef{Model, C, ScalarShape} where C}:
+2-element Vector{ConstraintRef}:
  eq_1 : v[1] + v[3] = 1.0
  v[1] * v[2] ^ 3.0 - 2.0 = 0
 julia> display(var_dmp.square)
 1-element Vector{VariableRef}:
  v[4]
 julia> display(con_dmp.square)
-1-element Vector{ConstraintRef{Model, MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.EqualTo{Float64}}, ScalarShape}}:
+1-element Vector{ConstraintRef}:
  eq_3 : v[4]² = 3.0
 julia> # As there are no unmatched constraints, the overconstrained subsystem
 julia> # is empty.
 ```
 
 """
-function dulmage_mendelsohn(igraph::IncidenceGraphInterface)
+function dulmage_mendelsohn(
+    igraph::IncidenceGraphInterface
+)::Tuple{DMConPartition, DMVarPartition}
     ncon = length(igraph._con_node_map)
     con_node_set = Set(1:ncon)
     con_dmp, var_dmp = dulmage_mendelsohn(igraph._graph, con_node_set)
@@ -332,9 +353,9 @@ end
 
 
 function dulmage_mendelsohn(
-    constraints::Vector{JuMP.ConstraintRef},
+    constraints::Vector{<:JuMP.ConstraintRef},
     variables::Vector{JuMP.VariableRef},
-)
+)::Tuple{DMConPartition, DMVarPartition}
     igraph = IncidenceGraphInterface(constraints, variables)
     return dulmage_mendelsohn(igraph)
 end

test/identify_variables.jl

@@ -199,6 +199,17 @@ function test_inequality_with_bounds()
     @test Set(variables) == pred_var_set
 end
 
+function test_two_constraints_same_type()
+    m = jmp.Model()
+    @jmp.variable(m, x[1:3])
+    @jmp.constraint(m, eq1, x[1] + x[2] == 2)
+    @jmp.constraint(m, eq2, x[2] + 2*x[3] == 3)
+    cons = [eq1, eq2]
+    vars = identify_unique_variables(cons)
+    pred_var_set = Set([x[1], x[2], x[3]])
+    @test Set(vars) == pred_var_set
+end
+
 function runtests()
     test_linear()
     test_quadratic()
@@ -213,6 +224,7 @@ function runtests()
     test_function_with_variable_squared()
     test_fixing_constraint()
     test_inequality_with_bounds()
+    test_two_constraints_same_type()
     return
 end
 

test/incidence_graph.jl

@@ -106,12 +106,61 @@ function test_include_bound_as_inequality()
     @test length(E) == 4
     pred_con_set = Set([eq1, jmp.LowerBoundRef(x[1]), jmp.LowerBoundRef(x[2])])
     @test pred_con_set == keys(con_node_map)
+    return
+end
+
+function test_construct_from_constraints()
+    m = jmp.Model()
+    @jmp.variable(m, x[1:3])
+    @jmp.constraint(m, eq1, x[1] + 2*x[2] == 1)
+    @jmp.constraint(m, eq2, x[2]*x[3] == 0.5)
+    cons = [eq1, eq2]
+    graph, con_node_map, var_node_map = get_bipartite_incidence_graph(cons)
+    A, B, E = graph
+
+    @test con_node_map[eq1] == 1
+    @test con_node_map[eq2] == 2
+
+    predicted_edges = [(eq1, x[1]), (eq1, x[2]), (eq2, x[2]), (eq2, x[3])]
+    @test length(E) == length(predicted_edges)
+    edge_set = Set(E)
+    for (con, var) in predicted_edges
+        @test (con_node_map[con], var_node_map[var]) in edge_set
+    end
+    return
+end
+
+function test_construct_from_constraints_and_variables()
+    m = jmp.Model()
+    @jmp.variable(m, x[1:3])
+    @jmp.constraint(m, eq1, x[1] + 2*x[2] == 1)
+    @jmp.constraint(m, eq2, x[2]*x[3] == 0.5)
+    cons = [eq2, eq1]
+    vars = [x[3], x[2], x[1]]
+    graph, con_node_map, var_node_map = get_bipartite_incidence_graph(cons, vars)
+    A, B, E = graph
+
+    @test con_node_map[eq1] == 2
+    @test con_node_map[eq2] == 1
+    @test var_node_map[x[1]] == 5
+    @test var_node_map[x[2]] == 4
+    @test var_node_map[x[3]] == 3
+
+    predicted_edges = [(eq1, x[1]), (eq1, x[2]), (eq2, x[2]), (eq2, x[3])]
+    @test length(E) == length(predicted_edges)
+    edge_set = Set(E)
+    for (con, var) in predicted_edges
+        @test (con_node_map[con], var_node_map[var]) in edge_set
+    end
+    return
 end
 
 function runtests()
     test_get_incidence_graph()
     test_get_incidence_graph_badconstraint()
     test_include_bound_as_inequality()
+    test_construct_from_constraints()
+    test_construct_from_constraints_and_variables()
     return
 end
 

test/interface.jl

@@ -236,6 +236,7 @@ function test_overconstrained_due_to_fixed_variable()
     @test length(var_dmp.overconstrained) == 2
     @test length(con_dmp.overconstrained) == 2
     @test length(con_dmp.unmatched) == 1
+    return
 end
 
 function test_overconstrained_due_to_including_bound()
@@ -249,6 +250,52 @@ function test_overconstrained_due_to_including_bound()
     @test length(var_dmp.overconstrained) == 2
     @test length(con_dmp.overconstrained) == 2
     @test length(con_dmp.unmatched) == 1
+    return
+end
+
+function test_interface_from_constraints_and_variables()
+    m = JuMP.Model()
+    @JuMP.variable(m, x[1:3])
+    @JuMP.constraint(m, eq1,  x[1] + x[2] == 2)
+    @JuMP.constraint(m, eq2, x[3]*x[2] == 1.1)
+    constraints = [eq1, eq2]
+    variables = [x[1], x[3]]
+    igraph = ji.IncidenceGraphInterface(constraints, variables)
+    _test_igraph_fields(igraph, constraints, variables)
+    return
+end
+
+function test_matching_from_constraints_and_variables()
+    m = JuMP.Model()
+    @JuMP.variable(m, x[1:3])
+    @JuMP.constraint(m, eq1,  x[1] + x[2] == 2)
+    @JuMP.constraint(m, eq2, x[3]*x[2] == 1.1)
+    constraints = [eq1, eq2]
+    variables = [x[1], x[3]]
+    matching = ji.maximum_matching(constraints, variables)
+    @test length(matching) == 2
+    @test matching[eq1] == x[1]
+    @test matching[eq2] == x[3]
+    return
+end
+
+function test_dulmage_mendelsohn_from_constraints_and_variables()
+    m = JuMP.Model()
+    @JuMP.variable(m, x[1:3])
+    @JuMP.constraint(m, eq1,  x[1] + x[2] == 2)
+    @JuMP.constraint(m, eq2, x[3]*x[2] == 1.1)
+    constraints = [eq1, eq2]
+    variables = [x[1], x[3]]
+    con_dmp, var_dmp = ji.dulmage_mendelsohn(constraints, variables)
+    @test con_dmp.unmatched == []
+    @test con_dmp.underconstrained == []
+    @test con_dmp.overconstrained == []
+    @test Set(con_dmp.square) == Set(constraints)
+    @test var_dmp.unmatched == []
+    @test var_dmp.underconstrained == []
+    @test var_dmp.overconstrained == []
+    @test Set(var_dmp.square) == Set(variables)
+    return
 end
 
 function runtests()
@@ -262,6 +309,9 @@ function runtests()
     test_dulmage_mendelsohn()
     test_overconstrained_due_to_fixed_variable()
     test_overconstrained_due_to_including_bound()
+    test_interface_from_constraints_and_variables()
+    test_matching_from_constraints_and_variables()
+    test_dulmage_mendelsohn_from_constraints_and_variables()
 end
 
 end