Add Variable.ZerosBridge

Author: blegat

src/Bridges/Constraint/bridge.jl

@@ -6,7 +6,7 @@ These can be obtained using `MOI.NumberOfConstraints` and `MOI.ListOfConstraintI
 Attributes of the bridged model such as `MOI.ConstraintDual` and `MOI.ConstraintPrimal`, can be obtained using the bridge in place of the constraint index.
 These calls are used by the `AbstractBridgeOptimizer` to communicate with the bridge so they should be implemented by the bridge.
 """
-abstract type AbstractBridge end
+abstract type AbstractBridge <: MOIB.AbstractBridge end
 
 """
     bridge_constraint(BT::Type{<:AbstractBridge}, model::MOI.ModelLike,
@@ -47,7 +47,10 @@ MOI.get(::AbstractBridge, ::MOI.NumberOfConstraints) = 0
 A `Vector{ConstraintIndex{F,S}}` with indices of all constraints of
 type `F`-in`S` created by the bride `b` in the model (i.e., of length equal to the value of `NumberOfConstraints{F,S}()`).
 """
-MOI.get(::AbstractBridge, ::MOI.ListOfConstraintIndices{F, S}) where {F, S} = CI{F, S}[]
+function MOI.get(::AbstractBridge,
+                 ::MOI.ListOfConstraintIndices{F, S}) where {F, S}
+    return MOI.ConstraintIndex{F, S}[]
+end
 
 """
     MOI.supports_constraint(BT::Type{<:AbstractBridge}, F::Type{<:MOI.AbstractFunction}, S::Type{<:MOI.AbstractSet})::Bool

src/Bridges/Variable/Variable.jl

@@ -12,12 +12,15 @@ include("bridge.jl")
 include("single_bridge_optimizer.jl")
 
 # Variable bridges
+include("zeros.jl")
+const Zeros{T, OT<:MOI.ModelLike} = SingleBridgeOptimizer{ZerosBridge{T}, OT}
 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, ZerosBridge{T})
     MOIB.add_bridge(bridged_model, NonposToNonnegBridge{T})
     MOIB.add_bridge(bridged_model, VectorizeBridge{T})
     return

src/Bridges/Variable/bridge.jl

@@ -1,4 +1,4 @@
-abstract type AbstractBridge end
+abstract type AbstractBridge <: MOIB.AbstractBridge end
 
 struct IndexInVector
     value::Int
@@ -29,6 +29,11 @@ The number of constraints of the type `F`-in-`S` created by the bridge `b` in th
 """
 MOI.get(b::AbstractBridge, ::MOI.NumberOfConstraints) = 0
 
+function MOI.get(::AbstractBridge,
+                 ::MOI.ListOfConstraintIndices{F, S}) where {F, S}
+    return MOI.ConstraintIndex{F, S}[]
+end
+
 """
     supports_constrained_variables(::Type{<:AbstractBridge},
                                    ::Type{<:MOI.AbstractSet})::Bool

src/Bridges/Variable/single_bridge_optimizer.jl

@@ -63,7 +63,10 @@ function add_key_for_bridge(map::Map, bridge::AbstractBridge,
     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))
+    mapping = unbridged_map(bridge, variable)
+    if mapping !== nothing
+        push!(map.unbridged_function, mapping)
+    end
     return variable, MOI.ConstraintIndex{MOI.SingleVariable, typeof(set)}(index)
 end
 function add_keys_for_bridge(map::Map, bridge::AbstractBridge,
@@ -82,13 +85,30 @@ function add_keys_for_bridge(map::Map, bridge::AbstractBridge,
             push!(map.sets, nothing)
         end
         for i in 1:MOI.dimension(set)
-            push!(map.unbridged_function, unbridged_map(bridge, variables[i],
-                                                        IndexInVector(i)))
+            mapping = unbridged_map(bridge, variables[i], IndexInVector(i))
+            if mapping !== nothing
+                push!(map.unbridged_function, mapping)
+            end
         end
         index = first(variables).value
         return variables, MOI.ConstraintIndex{MOI.VectorOfVariables, typeof(set)}(index)
     end
 end
+function function_for(map::Map, ci::MOI.ConstraintIndex{MOI.SingleVariable})
+    return MOI.SingleVariable(MOI.VariableIndex(ci.value))
+end
+function function_for(map::Map, ci::MOI.ConstraintIndex{MOI.VectorOfVariables})
+    variables = MOI.VariableIndex[]
+    for i in ci.value:-1:-length(map.bridges)
+        vi = MOI.VariableIndex(i)
+        if bridge_index(map, vi) == -ci.value
+            push!(variables, vi)
+        else
+            break
+        end
+    end
+    return MOI.VectorOfVariables(variables)
+end
 function Base.iterate(map::Map, state=1)
     while state ≤ length(map.bridges) && map.bridges[state] === nothing
         state += 1

src/Bridges/Variable/zeros.jl

@@ -0,0 +1,57 @@
+"""
+    ZerosBridge{T} <: Bridges.Variable.AbstractBridge
+
+Transforms constrained variables in [`MathOptInterface.Zeros`](@ref) zeros,
+which ends up creating no variables in the underlying model.
+The bridged variables are therefore similar to parameters with zero values.
+Parameters with non-zero value can be created with constrained variables in
+[`MOI.EqualTo`](@ref) by combining a [`VectorizeBridge`](@ref) and this bridge.
+The dual values cannot be determined by the bridged hence they are determined
+by the bridged optimizer using [`MathOptInterface.Utilities.get_fallback`](@ref).
+"""
+struct ZerosBridge{T} <: AbstractBridge
+    n::Int # Number of variables
+end
+function bridge_constrained_variables(::Type{ZerosBridge{T}},
+                                      model::MOI.ModelLike,
+                                      set::MOI.Zeros) where T
+    return ZerosBridge{T}(MOI.dimension(set))
+end
+
+function supports_constrained_variables(
+    ::Type{<:ZerosBridge}, ::Type{MOI.Zeros})
+    return true
+end
+function MOIB.added_constrained_variable_types(::Type{<:ZerosBridge})
+    return Tuple{DataType}[]
+end
+function MOIB.added_constraint_types(::Type{<:ZerosBridge})
+    return Tuple{DataType, DataType}[]
+end
+
+# Attributes, Bridge acting as a model
+MOI.get(bridge::ZerosBridge, ::MOI.NumberOfVariables) = 0
+function MOI.get(bridge::ZerosBridge, ::MOI.ListOfVariableIndices)
+    return MOI.VariableIndex[]
+end
+
+# Attributes, Bridge acting as a constraint
+
+function MOI.get(::MOI.ModelLike, ::MOI.ConstraintPrimal,
+                 bridge::ZerosBridge{T}) where T
+    return zeros(T, bridge.n)
+end
+MOIB.needs_fallback(::MOI.ModelLike, ::MOI.ConstraintDual, ::ZerosBridge) = true
+
+function MOI.get(::MOI.ModelLike, ::MOI.VariablePrimal,
+                 ::ZerosBridge{T}, ::IndexInVector) where T
+    return zero(T)
+end
+
+function MOIB.bridged_function(::ZerosBridge{T}, ::IndexInVector) where T
+    return zero(MOI.ScalarAffineFunction{T})
+end
+function unbridged_map(::ZerosBridge, ::MOI.VariableIndex,
+                       ::IndexInVector)
+    return nothing
+end

src/Bridges/bridge.jl

@@ -1,3 +1,10 @@
+abstract type AbstractBridge end
+
+function needs_fallback(::MOI.ModelLike, ::MOI.AbstractConstraintAttribute,
+                        ::AbstractBridge)
+    return false
+end
+
 """
     added_constraint_types(BT::Type{<:Variable.AbstractBridge})::Bool
 

src/Bridges/bridge_optimizer.jl

@@ -328,7 +328,15 @@ function MOI.get(b::AbstractBridgeOptimizer,
                  attr::MOI.AbstractConstraintAttribute, ci::CI)
     if is_bridged(b, typeof(ci))
         MOI.throw_if_not_valid(b, ci)
-        func = MOI.get(b, attr, bridge(b, ci))
+        br = bridge(b, ci)
+        if attr isa MOI.ConstraintFunction && br isa Variable.AbstractBridge
+            return Variable.function_for(Variable.bridges(b), ci)
+        end
+        if needs_fallback(b, attr, br)
+            func = MOIU.get_fallback(b, attr, ci)
+        else
+            func = MOI.get(b, attr, br)
+        end
     else
         func = MOI.get(b.model, attr, ci)
     end