Supports add constrained variable

src/Bridges/lazy_bridge_optimizer.jl

@@ -113,7 +113,9 @@ end
 
 function node(b::LazyBridgeOptimizer, S::Type{<:MOI.AbstractSet})
     F = MOIU.variable_function_type(S)
-    if MOI.supports_constraint(b.model, F, S)
+    if (MOI.supports_constraint(b.model, F, S) 
+        || (S <: MOI.AbstractScalarSet && MOI.supports_add_constrained_variable(b.model, S))
+        || (S <: MOI.AbstractVectorSet && MOI.supports_add_constrained_variables(b.model, S)))
         return VariableNode(0)
     end
     variable_node = get(b.variable_node, (S,), nothing)

src/Utilities/copy.jl

@@ -318,14 +318,21 @@ function default_copy_to(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bo
             for S in single_variable_types
         ]
     else
-        vector_of_variables_not_added = [
-            copy_vector_of_variables(dest, src, idxmap, S)
-            for S in vector_of_variables_types
-        ]
-        single_variable_not_added = [
-            copy_single_variable(dest, src, idxmap, S)
-            for S in single_variable_types
-        ]
+        # Order the copying of the variables by 1) their variable bridging cost 2) by starting with the vectors, as what was done before
+        # See issue #987
+        single_or_vector_variables_types = [(F, S) for (F, S) in constraint_types
+                                            if F == MOI.SingleVariable || F == MOI.VectorOfVariables]
+        sorted_by_cost = sortperm(single_or_vector_variables_types; by=((F, S),) -> (MOI.get(dest, MOI.VariableBridgingCost{S}()) - MOI.get(dest, MOI.ConstraintBridgingCost{F, S}()), F == MOI.SingleVariable))
+        vector_of_variables_not_added = Vector{Array{MOI.ConstraintIndex{MOI.VectorOfVariables, <:MOI.AbstractVectorSet}}}()
+        single_variable_not_added = Vector{Array{MOI.ConstraintIndex{MOI.SingleVariable, <:MOI.AbstractScalarSet}}}()
+        for i in sorted_by_cost
+            F, S = single_or_vector_variables_types[i]
+            if F == MOI.VectorOfVariables
+                push!(vector_of_variables_not_added, copy_vector_of_variables(dest, src, idxmap, S))
+            elseif F == MOI.SingleVariable
+                push!(single_variable_not_added, copy_single_variable(dest, src, idxmap, S))
+            end
+        end
     end
 
     copy_free_variables(dest, idxmap, vis_src, MOI.add_variables)

src/attributes.jl

@@ -269,8 +269,9 @@ function get end
 get(model::ModelLike, attr::AnyAttribute, idxs::Vector) = get.(model, attr, idxs)
 
 function get(model::ModelLike, attr::AnyAttribute, args...)
-    throw(ArgumentError("ModelLike of type $(typeof(model)) does not support accessing the attribute $attr"))
+    get_fallback(model, attr, args...)
 end
+get_fallback(model::ModelLike, attr::AnyAttribute, args...) = throw(ArgumentError("ModelLike of type $(typeof(model)) does not support accessing the attribute $attr"))
 
 """
     get!(output, model::ModelLike, args...)
@@ -1348,6 +1349,19 @@ end
 DualStatus() = DualStatus(1)
 _result_index_field(attr::DualStatus) = attr.N
 
+
+# Cost of bridging constrained variable in S
+struct VariableBridgingCost{S <: AbstractSet} <: AbstractModelAttribute 
+end
+get_fallback(model::ModelLike, ::VariableBridgingCost{S}) where {S<:AbstractScalarSet} = supports_add_constrained_variable(model, S) ? 0.0 : Inf
+get_fallback(model::ModelLike, ::VariableBridgingCost{S}) where {S<:AbstractVectorSet} = supports_add_constrained_variables(model, S) ? 0.0 : Inf
+
+# Cost of bridging F-in-S constraints
+struct ConstraintBridgingCost{F <: AbstractFunction, S <: AbstractSet} <: AbstractModelAttribute 
+end
+get_fallback(model::ModelLike, ::ConstraintBridgingCost{F, S}) where {F<:AbstractFunction, S<:AbstractSet} = supports_constraint(model, F, S) ? 0.0 : Inf
+
+
 """
     is_set_by_optimize(::AnyAttribute)
 
@@ -1427,6 +1441,8 @@ function is_copyable(::Union{ListOfOptimizerAttributesSet,
                              ListOfConstraintIndices,
                              ListOfConstraints,
                              ConstraintFunction,
-                             ConstraintSet})
+                             ConstraintSet,
+                             VariableBridgingCost,
+                             ConstraintBridgingCost})
     return false
 end

test/Utilities/copy.jl

@@ -157,3 +157,80 @@ end
         @test dest.added_constrained[idxmap[vi].value]
     end
 end
+
+
+mutable struct OrderingConstrainedVariablesModel <: MOI.ModelLike
+    lastConstraintIndex     ::Int
+    lastVarIndex            ::Int
+    OrderingConstrainedVariablesModel() = new(0, 0)
+end
+
+
+
+function MOI.add_variables(model::OrderingConstrainedVariablesModel, n)
+    m = model.lastVarIndex
+    model.lastVarIndex += n
+    return MOI.VariableIndex.(m .+ (1:n))
+end
+function MOI.add_variable(model::OrderingConstrainedVariablesModel)
+    return MOI.VariableIndex.(model.lastVarIndex += 1)
+end
+
+function MOI.add_constraint(model::OrderingConstrainedVariablesModel,
+    func::MOI.VectorOfVariables,
+    set::MOI.AbstractVectorSet)
+    return MOI.ConstraintIndex{typeof(func), typeof(set)}(model.lastConstraintIndex += 1)
+end
+function MOI.add_constraint(model::OrderingConstrainedVariablesModel,
+    func::MOI.SingleVariable,
+    set::MOI.AbstractScalarSet)
+    return MOI.ConstraintIndex{typeof(func), typeof(set)}(model.lastConstraintIndex += 1)
+end
+
+function MOI.copy_to(dest::OrderingConstrainedVariablesModel, src::MOI.ModelLike; kws...)
+    MOIU.automatic_copy_to(dest, src; kws...)
+end
+
+MOIU.supports_default_copy_to(model::OrderingConstrainedVariablesModel, ::Bool) = true
+
+function MOI.empty!(model::OrderingConstrainedVariablesModel)
+    model.lastConstraintIndex = 0
+    model.lastVarIndex = 0
+end
+
+
+MOI.supports_constraint(::OrderingConstrainedVariablesModel, ::Type{MOI.VectorOfVariables}, ::Type{MOI.Nonnegatives}) = false
+MOI.supports_add_constrained_variables(::OrderingConstrainedVariablesModel, ::Type{MOI.Nonnegatives}) = true
+
+MOI.supports_constraint(::OrderingConstrainedVariablesModel, ::Type{MOI.VectorOfVariables}, ::Type{MOI.Nonnegatives}) = true
+MOI.supports_add_constrained_variables(::OrderingConstrainedVariablesModel, ::Type{MOI.Nonpositives}) = false
+
+MOI.supports_constraint(::OrderingConstrainedVariablesModel, ::Type{MOI.SingleVariable}, ::Type{MOI.GreaterThan}) = false
+MOI.supports_add_constrained_variable(::OrderingConstrainedVariablesModel, ::Type{MOI.GreaterThan}) = true
+
+MOI.supports_constraint(::OrderingConstrainedVariablesModel, ::Type{MOI.SingleVariable}, ::Type{MOI.LessThan}) = true
+MOI.supports_add_constrained_variable(::OrderingConstrainedVariablesModel, ::Type{MOI.LessThan}) = false
+
+@testset "Create variables using supports_add_constrained_variable(s) (#987)" begin
+    # With vectors
+    src = MOIU.Model{Float64}()
+    a, c1 = MOI.add_constrained_variables(src, MOI.Nonpositives(3))
+    c2 = MOI.add_constraint(src, a, MOI.Nonnegatives(3))
+    dest = OrderingConstrainedVariablesModel()
+
+    index_map = MOI.copy_to(dest, src)
+
+    @test index_map[c1].value == 2
+    @test index_map[c2].value == 1
+
+    # With single variables
+    src = MOIU.Model{Float64}()
+    a, c1 = MOI.add_constrained_variable(src, MOI.LessThan(5.0))
+    c2 = MOI.add_constraint(src, a, MOI.GreaterThan(1.0))
+    dest = OrderingConstrainedVariablesModel()
+
+    index_map = MOI.copy_to(dest, src)
+
+    @test index_map[c1].value == 2
+    @test index_map[c2].value == 1
+end