Add model tests and create only nonnegative variables

Author: blegat

src/Bridges/Variable/free.jl

@@ -1,44 +1,38 @@
 """
     FreeBridge{T} <: Bridges.Variable.AbstractBridge
 
-Transforms constrained variables in [`MathOptInterface.Reals`](@ref)
-to the sum of constrained variables in [`MathOptInterface.Nonnegatives`](@ref)
-and constrained variables in [`MathOptInterface.Nonpositives`](@ref).
+Transforms constrained variables in [`MOI.Reals`](@ref) to the difference of
+constrained variables in [`MOI.Nonnegatives`](@ref).
 """
 struct FreeBridge{T} <: AbstractBridge
-    nonneg_variables::Vector{MOI.VariableIndex}
-    nonneg_constraint::MOI.ConstraintIndex{MOI.VectorOfVariables, MOI.Nonnegatives}
-    nonpos_variables::Vector{MOI.VariableIndex}
-    nonpos_constraint::MOI.ConstraintIndex{MOI.VectorOfVariables, MOI.Nonpositives}
+    variables::Vector{MOI.VariableIndex}
+    constraint::MOI.ConstraintIndex{MOI.VectorOfVariables, MOI.Nonnegatives}
 end
 function bridge_constrained_variable(::Type{FreeBridge{T}},
                                      model::MOI.ModelLike,
                                      set::MOI.Reals) where T
-    nonneg_variables, nonneg_constraint = MOI.add_constrained_variables(
-        model, MOI.Nonnegatives(MOI.dimension(set)))
-    nonpos_variables, nonpos_constraint = MOI.add_constrained_variables(
-        model, MOI.Nonpositives(MOI.dimension(set)))
-    return FreeBridge{T}(nonneg_variables, nonneg_constraint,
-                         nonpos_variables, nonpos_constraint)
+    variables, constraint = MOI.add_constrained_variables(
+        model, MOI.Nonnegatives(2MOI.dimension(set)))
+    return FreeBridge{T}(variables, constraint)
 end
 
 function supports_constrained_variable(
     ::Type{<:FreeBridge}, ::Type{MOI.Reals})
     return true
 end
 function MOIB.added_constrained_variable_types(::Type{<:FreeBridge})
-    return [(MOI.Nonnegatives,), (MOI.Nonpositives,)]
+    return [(MOI.Nonnegatives,)]
 end
 function MOIB.added_constraint_types(::Type{FreeBridge{T}}) where T
     return Tuple{DataType, DataType}[]
 end
 
 # Attributes, Bridge acting as a model
 function MOI.get(bridge::FreeBridge, ::MOI.NumberOfVariables)
-    return length(bridge.nonneg_variables) + length(bridge.nonpos_variables)
+    return length(bridge.variables)
 end
 function MOI.get(bridge::FreeBridge, ::MOI.ListOfVariableIndices)
-    return vcat(bridge.nonneg_variables, bridge.nonpos_variables)
+    return vcat(bridge.variables)
 end
 function MOI.get(bridge::FreeBridge,
                  ::MOI.NumberOfConstraints{MOI.VectorOfVariables,
@@ -48,80 +42,76 @@ end
 function MOI.get(bridge::FreeBridge,
                  ::MOI.ListOfConstraintIndices{MOI.VectorOfVariables,
                                                MOI.Nonnegatives})
-    return [bridge.nonneg_constraint]
-end
-function MOI.get(bridge::FreeBridge,
-                 ::MOI.NumberOfConstraints{MOI.VectorOfVariables,
-                                           MOI.Nonpositives})
-    return 1
-end
-function MOI.get(bridge::FreeBridge,
-                 ::MOI.ListOfConstraintIndices{MOI.VectorOfVariables,
-                                               MOI.Nonpositives})
-    return [bridge.nonpos_constraint]
+    return [bridge.constraint]
 end
 
 # References
 function MOI.delete(model::MOI.ModelLike, bridge::FreeBridge)
-    MOI.delete(model, bridge.nonneg_variables)
-    MOI.delete(model, bridge.nonpos_variables)
+    MOI.delete(model, bridge.variables)
 end
 
 function MOI.delete(model::MOI.ModelLike, bridge::FreeBridge, i::IndexInVector)
-    MOI.delete(model, bridge.nonneg_variables[i.value])
-    deleteat!(bridge.nonneg_variables, i.value)
-    MOI.delete(model, bridge.nonpos_variables[i.value])
-    deleteat!(bridge.nonpos_variables, i.value)
+    n = div(length(bridge.variables), 2)
+    MOI.delete(model, bridge.variables[i.value])
+    MOI.delete(model, bridge.variables[n + i.value])
+    deleteat!(bridge.variables, [i.value, n + i.value])
 end
 
 
 # Attributes, Bridge acting as a constraint
 
 function MOI.get(model::MOI.ModelLike, attr::MOI.ConstraintPrimal,
                  bridge::FreeBridge{T}) where T
-    return MOI.get(model, attr, bridge.nonneg_constraint) +
-        MOI.get(model, attr, bridge.nonpos_constraint)
+    n = div(length(bridge.variables), 2)
+    primal = MOI.get(model, attr, bridge.constraint)
+    return primal[1:n] - primal[n .+ (1:n)]
 end
-# The transformation is x_free = [I I] * [x_nonneg; x_nonpos]
+# The transformation is x_free = [I -I] * x
 # so the transformation of the dual is
-# [y_nonneg; y_nonpos] = [I; I] * y_free
+# y = [I; -I] * y_free
 # that is
-# y_nonneg = y_nonpos = y_free
-# We can therefore take either of them, let's take y_nonneg.
+# y[1:n] = -y[n .+ (1:n)] = y_free
+# We can therefore compute `y_free` from either of them, let's take `y[1:n]`.
 function MOI.get(model::MOI.ModelLike, attr::MOI.ConstraintDual,
                  bridge::FreeBridge{T}) where T
-    return MOI.get(model, attr, bridge.nonneg_constraint)
+    n = div(length(bridge.variables), 2)
+    return MOI.get(model, attr, bridge.constraint)[1:n]
 end
 
 function MOI.get(model::MOI.ModelLike, attr::MOI.VariablePrimal,
                  bridge::FreeBridge{T}, i::IndexInVector) where T
-    return MOI.get(model, attr, bridge.nonneg_variables[i.value]) +
-        MOI.get(model, attr, bridge.nonpos_variables[i.value])
+    n = div(length(bridge.variables), 2)
+    return MOI.get(model, attr, bridge.variables[i.value]) -
+        MOI.get(model, attr, bridge.variables[n + i.value])
 end
 
 function MOIB.bridged_function(bridge::FreeBridge{T}, i::IndexInVector) where T
-    return MOIU.operate(+, T, MOI.SingleVariable(bridge.nonneg_variables[i.value]),
-                        MOI.SingleVariable(bridge.nonpos_variables[i.value]))
+    n = div(length(bridge.variables), 2)
+    return MOIU.operate(-, T, MOI.SingleVariable(bridge.variables[i.value]),
+                        MOI.SingleVariable(bridge.variables[n + i.value]))
 end
-# x_free has been replaced by x_nonneg + x_nonpos.
-# To undo it we replace x_nonneg by x_free and x_nonpos by 0.
+# x_free has been replaced by x[i] - x[n + i].
+# To undo it we replace x[i] by x_free and x[n + i] by 0.
 function unbridged_map(bridge::FreeBridge{T}, vi::MOI.VariableIndex,
                        i::IndexInVector) where T
     sv = MOI.SingleVariable(vi)
+    # `unbridged_map` is required to return a `MOI.ScalarAffineFunction`.
     func = convert(MOI.ScalarAffineFunction{T}, sv)
-    return bridge.nonneg_variables[i.value] => func,
-        bridge.nonpos_variables[i.value] => zero(MOI.ScalarAffineFunction{T})
+    n = div(length(bridge.variables), 2)
+    return bridge.variables[i.value] => func,
+        bridge.variables[n + i.value] => zero(MOI.ScalarAffineFunction{T})
 end
 
 function MOI.set(model::MOI.ModelLike, attr::MOI.VariablePrimalStart,
                  bridge::FreeBridge, value, i::IndexInVector)
     if value < 0
         nonneg = zero(value)
-        nonpos = value
+        nonpos = -value
     else
         nonneg = value
         nonpos = zero(value)
     end
-    MOI.set(model, attr, bridge.nonneg_variables[i.value], nonneg)
-    MOI.set(model, attr, bridge.nonpos_variables[i.value], nonpos)
+    n = div(length(bridge.variables), 2)
+    MOI.set(model, attr, bridge.variables[i.value], nonneg)
+    MOI.set(model, attr, bridge.variables[n + i.value], nonpos)
 end

test/Bridges/Variable/free.jl

@@ -23,13 +23,47 @@ bridged_mock = MOIB.Variable.Free{Float64}(mock)
         )
     )
     MOIT.solve_multirow_vectoraffine_nonpos(bridged_mock, config)
+
+    MOI.set(bridged_mock, MOI.ConstraintName(),
+            MOI.get(mock, MOI.ListOfConstraintIndices{
+                MOI.VectorAffineFunction{Float64}, MOI.Nonpositives}()),
+            ["c"])
+
+    @testset "Mock model" begin
+        var_names = ["xpos", "xneg"]
+        MOI.set(mock, MOI.VariableName(),
+                MOI.get(mock, MOI.ListOfVariableIndices()), var_names)
+        MOI.set(bridged_mock, MOI.ConstraintName(),
+                MOI.get(mock, MOI.ListOfConstraintIndices{
+                    MOI.VectorOfVariables, MOI.Nonnegatives}()),
+                ["nonneg"])
+        s = """
+        variables: xpos, xneg
+        nonneg: [xpos, xneg] in MathOptInterface.Nonnegatives(2)
+        c: [4.0xpos + -4.0xneg + -1.0, 3.0xpos + -3.0xneg + -1.0] in MathOptInterface.Nonpositives(2)
+        maxobjective: xpos + -1.0xneg
+        """
+        model = MOIU.Model{Float64}()
+        MOIU.loadfromstring!(model, s)
+        MOIU.test_models_equal(mock, model, var_names, ["nonneg", "c"])
+    end
+    @testset "Bridged model" begin
+        s = """
+        variables: x
+        c: [4.0x + -1.0, 3.0x + -1.0] in MathOptInterface.Nonpositives(2)
+        maxobjective: 1.0x
+        """
+        model = MOIU.Model{Float64}()
+        MOIU.loadfromstring!(model, s)
+        MOIU.test_models_equal(bridged_mock, model, ["x"], ["c"])
+    end
 end
 
 @testset "Linear6" begin
     MOIU.set_mock_optimize!(mock,
         (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [0, 0, 0, 0]),
         (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [100, 0, 0, 0]),
-        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [100, 0, 0, -100],
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [100, 0, 0, 100],
         (MOI.ScalarAffineFunction{Float64}, MOI.GreaterThan{Float64}) => [1.0],
         (MOI.ScalarAffineFunction{Float64}, MOI.LessThan{Float64}) => [-1.0]
     ))
@@ -67,7 +101,7 @@ end
         MOIU.set_mock_optimize!(mock,
             (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [0, 0, 0, 0]),
             (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [100, 0, 0, 0]),
-            (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [100, 0, 0, -100],
+            (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [100, 0, 0, 100],
             (MOI.VectorAffineFunction{Float64}, MOI.Nonnegatives) => [[1.0]],
             (MOI.VectorAffineFunction{Float64}, MOI.Nonpositives) => [[-1.0]]
     ))
@@ -87,18 +121,61 @@ end
     @test MOI.supports(bridged_mock, MOI.VariablePrimalStart(), MOI.VariableIndex)
     MOI.set(bridged_mock, MOI.VariablePrimalStart(), [x, y], [1.0, -1.0])
     xa, xb, ya, yb = MOI.get(mock, MOI.ListOfVariableIndices())
-    @test MOI.get(mock, MOI.VariablePrimalStart(), [xa, xb, ya, yb]) == [1.0, 0.0, 0.0, -1.0]
+    @test MOI.get(mock, MOI.VariablePrimalStart(), [xa, xb, ya, yb]) == [1.0, 0.0, 0.0, 1.0]
 end
 
 @testset "Linear11" begin
     MOIU.set_mock_optimize!(mock,
-         (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [1.0, 0.0, 1.0, 0.0]),
-         (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [0.5, 0.0, 0.5, 0.0]))
+         (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [1.0, 1.0, 0.0, 0.0]),
+         (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [0.5, 0.5, 0.0, 0.0]))
     MOIT.linear11test(bridged_mock, config)
 
     vis = MOI.get(bridged_mock, MOI.ListOfVariableIndices())
     @test vis == MOI.VariableIndex.([-1, -2])
 
+    MOI.set(bridged_mock, MOI.ConstraintName(),
+            MOI.get(mock, MOI.ListOfConstraintIndices{
+                MOI.ScalarAffineFunction{Float64}, MOI.GreaterThan{Float64}}()),
+            ["c1"])
+    MOI.set(bridged_mock, MOI.ConstraintName(),
+            MOI.get(mock, MOI.ListOfConstraintIndices{
+                MOI.ScalarAffineFunction{Float64}, MOI.LessThan{Float64}}()),
+            ["c2"])
+
+    @testset "Mock model" begin
+        var_names = ["v1pos", "v2pos", "v1neg", "v2neg"]
+        MOI.set(mock, MOI.VariableName(),
+                MOI.get(mock, MOI.ListOfVariableIndices()), var_names)
+        MOI.set(bridged_mock, MOI.ConstraintName(),
+                MOI.get(mock, MOI.ListOfConstraintIndices{
+                    MOI.VectorOfVariables, MOI.Nonnegatives}()),
+                ["nonneg"])
+        s = """
+        variables: v1pos, v2pos, v1neg, v2neg
+        nonneg: [v1pos, v2pos, v1neg, v2neg] in MathOptInterface.Nonnegatives(4)
+        c1: v1pos + -1.0v1neg + v2pos + -1.0v2neg >= 1.0
+        c2: v1pos + -1.0v1neg + v2pos + -1.0v2neg <= 2.0
+        minobjective: v1pos + -1.0v1neg + v2pos + -1.0v2neg
+        """
+        model = MOIU.Model{Float64}()
+        MOIU.loadfromstring!(model, s)
+        MOIU.test_models_equal(mock, model, var_names, ["nonneg", "c1", "c2"])
+    end
+    @testset "Bridged model" begin
+        var_names = ["v1", "v2"]
+        MOI.set(bridged_mock, MOI.VariableName(),
+                vis, var_names)
+        s = """
+        variables: v1, v2
+        c1: v1 + v2 >= 1.0
+        c2: v1 + v2 <= 2.0
+        minobjective: v1 + v2
+        """
+        model = MOIU.Model{Float64}()
+        MOIU.loadfromstring!(model, s)
+        MOIU.test_models_equal(bridged_mock, model, var_names, ["c1", "c2"])
+    end
+
     test_delete_bridged_variable(bridged_mock, vis[1], MOI.Reals, 2, (
         (MOI.VectorOfVariables, MOI.Nonnegatives, 0),
         (MOI.VectorOfVariables, MOI.Nonpositives, 0)