Add scalar variable bridge

Author: blegat

docs/src/apireference.md

@@ -451,7 +451,8 @@ A bridge should implement the following functions to be usable by a bridge optim
 supports_constraint(::Type{<:Bridges.Constraint.AbstractBridge}, ::Type{<:AbstractFunction}, ::Type{<:AbstractSet})
 Bridges.Constraint.concrete_bridge_type
 Bridges.Constraint.bridge_constraint
-Bridges.Constraint.added_constraint_types
+Bridges.added_constrained_variable_types
+Bridges.added_constraint_types
 ```
 
 When querying the [`NumberOfVariables`](@ref), [`NumberOfConstraints`](@ref)

src/Bridges/Constraint/scalarize.jl

@@ -1,13 +1,7 @@
-const VectorLinearSet = Union{MOI.Zeros, MOI.Nonnegatives, MOI.Nonpositives}
-
-scalar_set_type(::Type{<:MOI.Zeros}, T::Type) = MOI.EqualTo{T}
-scalar_set_type(::Type{<:MOI.Nonpositives}, T::Type) = MOI.LessThan{T}
-scalar_set_type(::Type{<:MOI.Nonnegatives}, T::Type) = MOI.GreaterThan{T}
-
 """
     ScalarizeBridge{T, F, S}
 
-Transforms a constraint `AbstractVectorFunction`-in-`vector_set(S)` where
+Transforms a constraint `AbstractVectorFunction`-in-`vector_set_type(S)` where
 `S <: LPCone{T}` to `F`-in-`S`.
 """
 mutable struct ScalarizeBridge{T, F, S} <: AbstractBridge
@@ -17,7 +11,7 @@ end
 function bridge_constraint(::Type{ScalarizeBridge{T, F, S}},
                            model::MOI.ModelLike,
                            f::MOI.AbstractVectorFunction,
-                           set::VectorLinearSet) where {T, F, S}
+                           set::MOIU.VectorLinearSet) where {T, F, S}
     dimension = MOI.output_dimension(f)
     constants = MOI.constant(f, T)
     new_f = MOIU.scalarize(f, true)
@@ -30,7 +24,7 @@ end
 
 function MOI.supports_constraint(::Type{ScalarizeBridge{T}},
                                  ::Type{<:MOI.AbstractVectorFunction},
-                                 ::Type{<:VectorLinearSet}) where T
+                                 ::Type{<:MOIU.VectorLinearSet}) where T
     return true
 end
 MOIB.added_constrained_variable_types(::Type{<:ScalarizeBridge}) = Tuple{DataType}[]
@@ -39,8 +33,8 @@ function MOIB.added_constraint_types(::Type{ScalarizeBridge{T, F, S}}) where {T,
 end
 function concrete_bridge_type(::Type{<:ScalarizeBridge{T}},
                               F::Type{<:MOI.AbstractVectorFunction},
-                              S::Type{<:VectorLinearSet}) where T
-    return ScalarizeBridge{T, MOIU.scalar_type(F), scalar_set_type(S, T)}
+                              S::Type{<:MOIU.VectorLinearSet}) where T
+    return ScalarizeBridge{T, MOIU.scalar_type(F), MOIU.scalar_set_type(S, T)}
 end
 
 # Attributes, Bridge acting as a model
@@ -70,7 +64,7 @@ function MOI.get(model::MOI.ModelLike, attr::MOI.ConstraintFunction,
 end
 function MOI.get(::MOI.ModelLike, ::MOI.ConstraintSet,
                  bridge::ScalarizeBridge{T, F, S}) where {T, F, S}
-    return vector_set_type(S)(length(bridge.constants))
+    return MOIU.vector_set_type(S)(length(bridge.constants))
 end
 
 function MOI.get(model::MOI.ModelLike, attr::MOI.ConstraintPrimal,

src/Bridges/Constraint/single_bridge_optimizer.jl

@@ -128,7 +128,7 @@ function Base.iterate(map::Map, state)
     if state[1] == 1
         return _iterate1(map, state[2])
     else
-        return _iterate2(map, iterate(map.single_variable_constraint, state[2]))
+        return _iterate2(map, iterate(map.single_variable_constraints, state[2]))
     end
 end
 
@@ -174,7 +174,7 @@ function MOIB.is_bridged(b::SingleBridgeOptimizer, F::Type{<:MOI.AbstractFunctio
                     S::Type{<:MOI.AbstractSet})
     return MOIB.supports_bridging_constraint(b, F, S)
 end
-function MOIB.is_bridged(b::SingleBridgeOptimizer, S::Type{<:MOI.AbstractVectorSet})
+function MOIB.is_bridged(b::SingleBridgeOptimizer, S::Type{<:MOI.AbstractSet})
     return false
 end
 function MOIB.bridge_type(::SingleBridgeOptimizer{BT},

src/Bridges/Constraint/vectorize.jl

@@ -1,13 +1,3 @@
-const ScalarLinearSet{T} = Union{MOI.EqualTo{T}, MOI.LessThan{T}, MOI.GreaterThan{T}}
-
-vector_set(::MOI.EqualTo) = MOI.Zeros(1)
-vector_set(::MOI.LessThan) = MOI.Nonpositives(1)
-vector_set(::MOI.GreaterThan) = MOI.Nonnegatives(1)
-
-vector_set_type(::Type{<:MOI.EqualTo}) = MOI.Zeros
-vector_set_type(::Type{<:MOI.LessThan}) = MOI.Nonpositives
-vector_set_type(::Type{<:MOI.GreaterThan}) = MOI.Nonnegatives
-
 """
     VectorizeBridge{T, F, S, G}
 
@@ -20,7 +10,7 @@ mutable struct VectorizeBridge{T, F, S, G} <: AbstractBridge
 end
 function bridge_constraint(::Type{VectorizeBridge{T, F, S, G}},
                            model::MOI.ModelLike, g::G,
-                           set::MOI.AbstractScalarSet) where {T, F, S, G}
+                           set::MOIU.ScalarLinearSet{T}) where {T, F, S, G}
     set_constant = MOI.constant(set)
     h = MOIU.operate(-, T, g, set_constant)
     if -set_constant != MOI.constant(h)[1]
@@ -30,13 +20,13 @@ function bridge_constraint(::Type{VectorizeBridge{T, F, S, G}},
                                                 typeof(set)}(constant))
     end
     f = MOIU.operate(vcat, T, h)
-    vector_constraint = MOI.add_constraint(model, f, vector_set(set))
+    vector_constraint = MOI.add_constraint(model, f, S(1))
     return VectorizeBridge{T, F, S, G}(vector_constraint, set_constant)
 end
 
 function MOI.supports_constraint(::Type{VectorizeBridge{T}},
                                 ::Type{<:MOI.AbstractScalarFunction},
-                                ::Type{<:ScalarLinearSet{T}}) where T
+                                ::Type{<:MOIU.ScalarLinearSet{T}}) where T
     return true
 end
 MOIB.added_constrained_variable_types(::Type{<:VectorizeBridge}) = Tuple{DataType}[]
@@ -45,10 +35,10 @@ function MOIB.added_constraint_types(::Type{<:VectorizeBridge{T, F, S}}) where {
 end
 function concrete_bridge_type(::Type{<:VectorizeBridge{T}},
                               G::Type{<:MOI.AbstractScalarFunction},
-                              S::Type{<:ScalarLinearSet{T}}) where T
+                              S::Type{<:MOIU.ScalarLinearSet{T}}) where T
     H = MOIU.promote_operation(-, T, G, T)
     F = MOIU.promote_operation(vcat, T, H)
-    return VectorizeBridge{T, F, vector_set_type(S), G}
+    return VectorizeBridge{T, F, MOIU.vector_set_type(S), G}
 end
 
 # Attributes, Bridge acting as a model
@@ -74,8 +64,7 @@ function MOI.get(model::MOI.ModelLike, attr::MOI.ConstraintPrimal,
     @assert length(x) == 1
     y = x[1]
     status = MOI.get(model, MOI.PrimalStatus(attr.N))
-    if status != MOI.INFEASIBILITY_CERTIFICATE &&
-       status != MOI.NEARLY_INFEASIBILITY_CERTIFICATE
+    if !MOIU.is_ray(status)
        # If it is an infeasibility certificate, it is a ray and satisfies the
        # homogenized problem, see https://github.com/JuliaOpt/MathOptInterface.jl/issues/433
        # Otherwise, we need to add the set constant since the ConstraintPrimal
@@ -98,7 +87,7 @@ function MOI.modify(model::MOI.ModelLike, bridge::VectorizeBridge,
                                   [(1, change.new_coefficient)]))
 end
 function MOI.set(model::MOI.ModelLike, ::MOI.ConstraintSet,
-                 bridge::VectorizeBridge, new_set::ScalarLinearSet)
+                 bridge::VectorizeBridge, new_set::MOIU.ScalarLinearSet)
     bridge.set_constant = MOI.constant(new_set)
     MOI.modify(model, bridge.vector_constraint,
                MOI.VectorConstantChange([-bridge.set_constant]))
@@ -112,5 +101,5 @@ function MOI.get(model::MOI.ModelLike, attr::MOI.ConstraintFunction,
 end
 function MOI.get(model::MOI.ModelLike, ::MOI.ConstraintSet,
                  bridge::VectorizeBridge{T, F, S}) where {T, F, S}
-    return scalar_set_type(S, T)(bridge.set_constant)
+    return MOIU.scalar_set_type(S, T)(bridge.set_constant)
 end

src/Bridges/Variable/Variable.jl

@@ -14,9 +14,12 @@ include("single_bridge_optimizer.jl")
 # Variable bridges
 include("flip_sign.jl")
 const NonposToNonneg{T, OT<:MOI.ModelLike} = SingleBridgeOptimizer{NonposToNonnegBridge{T}, OT}
+include("vectorize.jl")
+const Vectorize{T, OT<:MOI.ModelLike} = SingleBridgeOptimizer{VectorizeBridge{T}, OT}
 
 function add_all_bridges(bridged_model, T::Type)
     MOIB.add_bridge(bridged_model, NonposToNonnegBridge{T})
+    MOIB.add_bridge(bridged_model, VectorizeBridge{T})
     return
 end
 

src/Bridges/Variable/bridge.jl

@@ -4,6 +4,8 @@ struct IndexInVector
     value::Int
 end
 
+function bridge_constrained_variable end
+
 """
     bridge_constrained_variables(BT::Type{<:AbstractBridge}, model::MOI.ModelLike,
                                 set::MOI.AbstractVectorSet)
@@ -29,13 +31,13 @@ MOI.get(b::AbstractBridge, ::MOI.NumberOfConstraints) = 0
 
 """
     supports_constrained_variables(::Type{<:AbstractBridge},
-                                       ::Type{<:MOI.AbstractVectorSet})::Bool
+                                   ::Type{<:MOI.AbstractSet})::Bool
 
 Return a `Bool` indicating whether the bridges of type `BT` support bridging
 constrained variables in `S`.
 """
 function supports_constrained_variables(::Type{<:AbstractBridge},
-                                        ::Type{<:MOI.AbstractVectorSet})
+                                        ::Type{<:MOI.AbstractSet})
     return false
 end
 

src/Bridges/Variable/flip_sign.jl

@@ -21,13 +21,11 @@ function MOIB.added_constraint_types(::Type{<:FlipSignBridge})
     return Tuple{DataType, DataType}[]
 end
 
-# Attributes, Bridge acting as an model
-function MOI.get(bridge::FlipSignBridge{T, <:MOI.AbstractVectorSet},
-                 ::MOI.NumberOfVariables) where T
+# Attributes, Bridge acting as a model
+function MOI.get(bridge::FlipSignBridge, ::MOI.NumberOfVariables)
     return length(bridge.flipped_variables)
 end
-function MOI.get(bridge::FlipSignBridge{T, <:MOI.AbstractVectorSet},
-                 ::MOI.ListOfVariableIndices) where T
+function MOI.get(bridge::FlipSignBridge, ::MOI.ListOfVariableIndices)
     return bridge.flipped_variables
 end
 function MOI.get(::FlipSignBridge{T, S1, S2},
@@ -39,6 +37,7 @@ function MOI.get(::FlipSignBridge{T, S1, S2},
     return [bridge.flipped_constraint]
 end
 
+# Attributes, Bridge acting as a constraint
 
 function MOI.get(model::MOI.ModelLike,
                  attr::Union{MOI.ConstraintPrimal, MOI.ConstraintDual},
@@ -55,6 +54,11 @@ function MOIB.bridged_function(bridge::FlipSignBridge{T}, i::IndexInVector) wher
     func = MOI.SingleVariable(bridge.flipped_variables[i.value])
     return MOIU.operate(-, T, func)
 end
+function unbridged_map(bridge::FlipSignBridge{T}, vi::MOI.VariableIndex,
+                       i::IndexInVector) where T
+    func = MOIU.operate(-, T, MOI.SingleVariable(vi))
+    return bridge.flipped_variables[i.value] => func
+end
 
 """
     NonposToNonnegBridge{T, F<:MOI.AbstractVectorFunction, G<:MOI.AbstractVectorFunction} <:

src/Bridges/Variable/single_bridge_optimizer.jl

@@ -7,17 +7,24 @@ struct Map <: AbstractDict{MOI.VariableIndex, AbstractBridge}
     # `i` -> `bridge`: `VariableIndex(-i)` was bridged by `bridge`.
     bridges::Vector{Union{Nothing, AbstractBridge}}
     sets::Vector{Union{Nothing, DataType}}
+    unbridged_function::Dict{MOI.VariableIndex, MOI.AbstractScalarFunction}
 end
-Map() = Map(Int[], Union{Nothing, AbstractBridge}[], Union{Nothing, DataType}[])
+Map() = Map(Int[], Union{Nothing, AbstractBridge}[], Union{Nothing, DataType}[], Dict{MOI.VariableIndex, MOI.AbstractScalarFunction}())
 Base.isempty(map::Map) = all(bridge -> bridge === nothing, map.bridges)
 function Base.empty!(map::Map)
     empty!(map.index_in_vector_of_variables)
     empty!(map.bridges)
     empty!(map.sets)
+    empty!(map.unbridged_function)
     return map
 end
 function bridge_index(map::Map, vi::MOI.VariableIndex)
-    return -vi.value - map.index_in_vector_of_variables[-vi.value] + 1
+    index = map.index_in_vector_of_variables[-vi.value]
+    if iszero(index)
+        return -vi.value
+    else
+        return -vi.value - index + 1
+    end
 end
 function Base.haskey(map::Map, vi::MOI.VariableIndex)
     return -length(map.bridges) ≤ vi.value ≤ -1 &&
@@ -27,8 +34,8 @@ function Base.getindex(map::Map, vi::MOI.VariableIndex)
     return map.bridges[bridge_index(map, vi)]
 end
 function Base.delete!(map::Map, vi::MOI.VariableIndex)
-    map.bridges[bridge_index(vi)] = nothing
-    map.sets[bridge_index(vi)] = nothing
+    map.bridges[bridge_index(map, vi)] = nothing
+    map.sets[bridge_index(map, vi)] = nothing
     return map
 end
 function Base.keys(map::Map)
@@ -49,6 +56,16 @@ function index_in_vector_of_variables(map::Map, vi::MOI.VariableIndex)
     return IndexInVector(map.index_in_vector_of_variables[-vi.value])
 end
 has_bridges(map::Map) = !isempty(map.index_in_vector_of_variables)
+function add_key_for_bridge(map::Map, bridge::AbstractBridge,
+                            set::MOI.AbstractScalarSet)
+    index = -(length(map.bridges) + 1)
+    variable = MOI.VariableIndex(index)
+    push!(map.index_in_vector_of_variables, 0)
+    push!(map.bridges, bridge)
+    push!(map.sets, typeof(set))
+    push!(map.unbridged_function, unbridged_map(bridge, variable))
+    return variable, MOI.ConstraintIndex{MOI.SingleVariable, typeof(set)}(index)
+end
 function add_keys_for_bridge(map::Map, bridge::AbstractBridge,
                              set::MOI.AbstractVectorSet)
     if iszero(MOI.dimension(set))
@@ -64,6 +81,10 @@ function add_keys_for_bridge(map::Map, bridge::AbstractBridge,
             push!(map.bridges, nothing)
             push!(map.sets, nothing)
         end
+        for i in 1:MOI.dimension(set)
+            push!(map.unbridged_function, unbridged_map(bridge, variables[i],
+                                                        IndexInVector(i)))
+        end
         index = first(variables).value
         return variables, MOI.ConstraintIndex{MOI.VectorOfVariables, typeof(set)}(index)
     end
@@ -78,6 +99,9 @@ function Base.iterate(map::Map, state=1)
         return MOI.VariableIndex(-state) => map.bridges[state], state + 1
     end
 end
+function unbridged_function(map::Map, vi::MOI.VariableIndex)
+    return get(map.unbridged_function, vi, MOI.SingleVariable(vi))
+end
 
 struct EmptyMap <: AbstractDict{MOI.VariableIndex, AbstractBridge} end
 Base.isempty(::EmptyMap) = true
@@ -109,19 +133,27 @@ function bridges(bridge::MOI.Bridges.AbstractBridgeOptimizer)
 end
 bridges(bridge::SingleBridgeOptimizer) = bridge.map
 
+function MOIB.supports_bridging_constraint(
+    b::SingleBridgeOptimizer{BT}, ::Type{MOI.SingleVariable},
+    S::Type{<:MOI.AbstractScalarSet}) where BT
+    return supports_constrained_variables(BT, S)
+end
 function MOIB.supports_bridging_constraint(
     b::SingleBridgeOptimizer{BT}, ::Type{MOI.VectorOfVariables},
     S::Type{<:MOI.AbstractVectorSet}) where BT
     return supports_constrained_variables(BT, S)
 end
+function MOIB.is_bridged(b::SingleBridgeOptimizer, S::Type{<:MOI.AbstractScalarSet})
+    return MOIB.supports_bridging_constraint(b, MOI.SingleVariable, S)
+end
+function MOIB.is_bridged(b::SingleBridgeOptimizer, S::Type{<:MOI.AbstractVectorSet})
+    return MOIB.supports_bridging_constraint(b, MOI.VectorOfVariables, S)
+end
 function MOIB.is_bridged(::SingleBridgeOptimizer,
                          ::Type{<:MOI.AbstractFunction},
                          ::Type{<:MOI.AbstractSet})
     return false
 end
-function MOIB.is_bridged(b::SingleBridgeOptimizer, S::Type{<:MOI.AbstractVectorSet})
-    return MOIB.supports_bridging_constraint(b, MOI.VectorOfVariables, S)
-end
 function MOIB.bridge_type(::SingleBridgeOptimizer{BT},
                           ::Type{<:MOI.AbstractSet}) where BT
     return BT