Merge pull request #439 from JuliaOpt/bl/intervalanyfunc

Support any function for interval bridge

Author: blegat

src/Bridges/Bridges.jl

@@ -47,7 +47,7 @@ function fullbridgeoptimizer(model::MOI.ModelLike, ::Type{T}) where T
 end
 
 include("intervalbridge.jl")
-@bridge SplitInterval SplitIntervalBridge () (Interval,) () () () (ScalarAffineFunction,) () ()
+@bridge SplitInterval SplitIntervalBridge () (Interval,) () () (SingleVariable,) (ScalarAffineFunction, ScalarQuadraticFunction) () ()
 include("rsocbridge.jl")
 @bridge RSOC RSOCBridge () () (RotatedSecondOrderCone,) () () () (VectorOfVariables,) (VectorAffineFunction,)
 include("geomeanbridge.jl")

src/Bridges/bridge.jl

@@ -43,3 +43,25 @@ MOI.supportsconstraint(::Type{<:AbstractBridge}, ::Type{<:MOI.AbstractFunction},
 Return a list of the types of constraints that bridges of type `BT` add for bridging an `F`-in-`S` constraints.
 """
 function addedconstrainttypes end
+
+"""
+    concrete_bridge_type(BT::Type{<:AbstractBridge},
+                         F::Type{<:MOI.AbstractFunction},
+                         S::Type{<:MOI.AbstractSet})::DataType
+
+Return the concrete type of the bridge supporting `F`-in-`S` constraints. This
+function can only be called if `MOI.supportsconstraint(BT, F, S)` is `true`.
+
+## Examples
+
+The following returns `SplitIntervalBridge{Float64, MOI.SingleVariable}`:
+```julia
+concrete_bridge_type(SplitIntervalBridge{Float64}, MOI.SingleVariable,
+                                                   MOI.Interval{Float64})
+```
+"""
+function concrete_bridge_type(bridge_type::DataType,
+                              ::Type{<:MOI.AbstractFunction},
+                              ::Type{<:MOI.AbstractSet})
+    return bridge_type
+end

src/Bridges/bridgeoptimizer.jl

@@ -3,24 +3,25 @@
 
 The `SplitIntervalBridge` splits a constraint ``l ≤ ⟨a, x⟩ + α ≤ u`` into the constraints ``⟨a, x⟩ + α ≥ l`` and ``⟨a, x⟩ + α ≤ u``.
 """
-struct SplitIntervalBridge{T} <: AbstractBridge
-    lower::CI{MOI.ScalarAffineFunction{T}, MOI.GreaterThan{T}}
-    upper::CI{MOI.ScalarAffineFunction{T}, MOI.LessThan{T}}
+struct SplitIntervalBridge{T, F<:MOI.AbstractScalarFunction} <: AbstractBridge
+    lower::CI{F, MOI.GreaterThan{T}}
+    upper::CI{F, MOI.LessThan{T}}
 end
-function SplitIntervalBridge{T}(model, f::MOI.ScalarAffineFunction{T}, s::MOI.Interval{T}) where T
+function SplitIntervalBridge{T, F}(model, f::F, s::MOI.Interval{T}) where {T, F}
     lower = MOI.addconstraint!(model, f, MOI.GreaterThan(s.lower))
     upper = MOI.addconstraint!(model, f, MOI.LessThan(s.upper))
-    SplitIntervalBridge(lower, upper)
+    return SplitIntervalBridge(lower, upper)
 end
 
-MOI.supportsconstraint(::Type{SplitIntervalBridge{T}}, ::Type{MOI.ScalarAffineFunction{T}}, ::Type{MOI.Interval{T}}) where T = true
-addedconstrainttypes(::Type{SplitIntervalBridge{T}}, ::Type{MOI.ScalarAffineFunction{T}}, ::Type{MOI.Interval{T}}) where T = [(MOI.ScalarAffineFunction{T}, MOI.GreaterThan{T}), (MOI.ScalarAffineFunction{T}, MOI.LessThan{T})]
+MOI.supportsconstraint(::Type{SplitIntervalBridge{T}}, ::Type{<:MOI.AbstractScalarFunction}, ::Type{MOI.Interval{T}}) where T = true
+addedconstrainttypes(::Type{SplitIntervalBridge{T}}, F::Type{<:MOI.AbstractScalarFunction}, ::Type{MOI.Interval{T}}) where T = [(F, MOI.GreaterThan{T}), (F, MOI.LessThan{T})]
+concrete_bridge_type(::Type{<:SplitIntervalBridge}, F::Type{<:MOI.AbstractScalarFunction}, ::Type{MOI.Interval{T}}) where T = SplitIntervalBridge{T, F}
 
 # Attributes, Bridge acting as an model
-MOI.get(b::SplitIntervalBridge{T}, ::MOI.NumberOfConstraints{MOI.ScalarAffineFunction{T}, MOI.LessThan{T}}) where T = 1
-MOI.get(b::SplitIntervalBridge{T}, ::MOI.NumberOfConstraints{MOI.ScalarAffineFunction{T}, MOI.GreaterThan{T}}) where T = 1
-MOI.get(b::SplitIntervalBridge{T}, ::MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{T}, MOI.GreaterThan{T}}) where {T} = [b.lower]
-MOI.get(b::SplitIntervalBridge{T}, ::MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{T}, MOI.LessThan{T}}) where {T} = [b.upper]
+MOI.get(b::SplitIntervalBridge{T, F}, ::MOI.NumberOfConstraints{F, MOI.LessThan{T}}) where {T, F} = 1
+MOI.get(b::SplitIntervalBridge{T, F}, ::MOI.NumberOfConstraints{F, MOI.GreaterThan{T}}) where {T, F} = 1
+MOI.get(b::SplitIntervalBridge{T, F}, ::MOI.ListOfConstraintIndices{F, MOI.GreaterThan{T}}) where {T, F} = [b.lower]
+MOI.get(b::SplitIntervalBridge{T, F}, ::MOI.ListOfConstraintIndices{F, MOI.LessThan{T}}) where {T, F} = [b.upper]
 
 # Indices
 function MOI.delete!(model::MOI.ModelLike, c::SplitIntervalBridge)
@@ -29,25 +30,23 @@ function MOI.delete!(model::MOI.ModelLike, c::SplitIntervalBridge)
 end
 
 # Attributes, Bridge acting as a constraint
-function MOI.canget(model::MOI.ModelLike, a::MOI.ConstraintPrimal, ::Type{SplitIntervalBridge{T}}) where T
-    MOI.canget(model, a, CI{MOI.ScalarAffineFunction{T}, MOI.GreaterThan{T}})
+function MOI.canget(model::MOI.ModelLike, attr::MOI.ConstraintPrimal, ::Type{SplitIntervalBridge{T, F}}) where {T, F}
+    return MOI.canget(model, attr, CI{F, MOI.GreaterThan{T}})
 end
-function MOI.get(model::MOI.ModelLike, a::MOI.ConstraintPrimal, c::SplitIntervalBridge)
+function MOI.get(model::MOI.ModelLike, attr::MOI.ConstraintPrimal, c::SplitIntervalBridge)
     # lower and upper should give the same value
-    MOI.get(model, MOI.ConstraintPrimal(), c.lower)
+    return MOI.get(model, attr, c.lower)
 end
-function MOI.canget(model::MOI.ModelLike, a::MOI.ConstraintDual, ::Type{SplitIntervalBridge{T}}) where T
-    MOI.canget(model, a, CI{MOI.ScalarAffineFunction{T}, MOI.GreaterThan{T}}) &&
-    MOI.canget(model, a, CI{MOI.ScalarAffineFunction{T}, MOI.LessThan{T}})
+function MOI.canget(model::MOI.ModelLike, attr::MOI.ConstraintDual, ::Type{SplitIntervalBridge{T, F}}) where {T, F}
+    return MOI.canget(model, attr, CI{F, MOI.GreaterThan{T}}) &&
+           MOI.canget(model, attr, CI{F, MOI.LessThan{T}})
 end
 function MOI.get(model::MOI.ModelLike, a::MOI.ConstraintDual, c::SplitIntervalBridge)
-    lowd = MOI.get(model, MOI.ConstraintDual(), c.lower) # Should be nonnegative
-    uppd = MOI.get(model, MOI.ConstraintDual(), c.upper) # Should be nonpositive
-    if lowd > -uppd
-        lowd
-    else
-        uppd
-    end
+    # Should be nonnegative
+    lower_dual = MOI.get(model, MOI.ConstraintDual(), c.lower)
+    # Should be nonpositive
+    upper_dual = MOI.get(model, MOI.ConstraintDual(), c.upper)
+    return lower_dual > -upper_dual ? lower_dual : upper_dual
 end
 
 # Constraints
@@ -57,7 +56,8 @@ function MOI.modify!(model::MOI.ModelLike, c::SplitIntervalBridge, change::MOI.A
 end
 
 MOI.supports(model::MOI.ModelLike, ::MOI.ConstraintFunction, ::Type{<:SplitIntervalBridge}) = true
-function MOI.set!(model::MOI.ModelLike, ::MOI.ConstraintFunction, c::SplitIntervalBridge, func::MOI.ScalarAffineFunction)
+function MOI.set!(model::MOI.ModelLike, ::MOI.ConstraintFunction,
+                  c::SplitIntervalBridge{T, F}, func::F) where {T, F}
     MOI.set!(model, MOI.ConstraintFunction(), c.lower, func)
     MOI.set!(model, MOI.ConstraintFunction(), c.upper, func)
 end

src/Bridges/intervalbridge.jl

@@ -14,15 +14,15 @@ struct LazyBridgeOptimizer{OT<:MOI.ModelLike, MT<:MOI.ModelLike} <: AbstractBrid
     model::OT   # Internal model
     bridged::MT # Model containing bridged constraints
     bridges::Dict{CI, AbstractBridge} # Constraint Index of bridged constraint in bridged -> Bridge
-    bridgetypes::Vector{DataType} # List of types of available bridges
+    bridgetypes::Vector{Any} # List of types of available bridges
     dist::Dict{Tuple{DataType, DataType}, Int}      # (F, S) -> Number of bridges that need to be used for an `F`-in-`S` constraint
     best::Dict{Tuple{DataType, DataType}, DataType} # (F, S) -> Bridge to be used for an `F`-in-`S` constraint
 end
 function LazyBridgeOptimizer(model::MOI.ModelLike, bridged::MOI.ModelLike)
     LazyBridgeOptimizer{typeof(model),
                              typeof(bridged)}(model, bridged,
                                               Dict{CI, AbstractBridge}(),
-                                              DataType[],
+                                              Any[],
                                               Dict{Tuple{DataType, DataType}, Int}(),
                                               Dict{Tuple{DataType, DataType}, DataType}())
 end
@@ -49,7 +49,7 @@ function update_dist!(b::LazyBridgeOptimizer, constraints)
                     # Is it better that what can currently be done ?
                     if dist < _dist(b, F, S)
                         b.dist[(F, S)] = dist
-                        b.best[(F, S)] = BT
+                        b.best[(F, S)] = concrete_bridge_type(BT, F, S)
                         changed = true
                     end
                 end
@@ -103,7 +103,7 @@ function supportsbridgingconstraint(b::LazyBridgeOptimizer, F::Type{<:MOI.Abstra
     update_constraint!(b, F, S)
     (F, S) in keys(b.best)
 end
-function bridgetype(b::LazyBridgeOptimizer{BT}, F::Type{<:MOI.AbstractFunction}, S::Type{<:MOI.AbstractSet}) where BT
+function bridge_type(b::LazyBridgeOptimizer{BT}, F::Type{<:MOI.AbstractFunction}, S::Type{<:MOI.AbstractSet}) where BT
     update_constraint!(b, F, S)
     b.best[(F, S)]
 end

src/Bridges/lazybridgeoptimizer.jl

@@ -14,7 +14,7 @@ function SingleBridgeOptimizer{BT, MT}(model::OT) where {BT, MT, OT <: MOI.Model
 end
 
 isbridged(b::SingleBridgeOptimizer, ::Type{<:MOI.AbstractFunction}, ::Type{<:MOI.AbstractSet}) = false
-bridgetype(b::SingleBridgeOptimizer{BT}, ::Type{<:MOI.AbstractFunction}, ::Type{<:MOI.AbstractSet}) where BT = BT
+bridge_type(b::SingleBridgeOptimizer{BT}, F::Type{<:MOI.AbstractFunction}, S::Type{<:MOI.AbstractSet}) where BT = BT
 
 # :((Zeros, SecondOrderCone)) -> (:(MOI.Zeros), :(MOI.SecondOrderCone))
 _tuple_prefix_moi(t) = MOIU._moi.(t.args)

src/Bridges/singlebridgeoptimizer.jl

@@ -116,8 +116,10 @@ struct RSOCtoPSDCBridge{T} <: AbstractBridge
     dim::Int
     cr::CI{MOI.VectorAffineFunction{T}, MOI.PositiveSemidefiniteConeTriangle}
 end
+
 MOI.supportsconstraint(::Type{RSOCtoPSDCBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.RotatedSecondOrderCone}) where T = true
 addedconstrainttypes(::Type{RSOCtoPSDCBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.RotatedSecondOrderCone}) where T = [(MOI.VectorAffineFunction{T}, MOI.PositiveSemidefiniteConeTriangle)]
+
 function RSOCtoPSDCBridge{T}(instance, f, s::MOI.RotatedSecondOrderCone) where T
     d = MOI.dimension(s)-1
     cr = MOI.addconstraint!(instance, _RSOCtoPSDCaff(f, T), MOI.PositiveSemidefiniteConeTriangle(d))

src/Bridges/soctopsdbridge.jl

@@ -1,5 +1,5 @@
 # Model not supporting Interval
-MOIU.@model SimpleModel () (EqualTo, GreaterThan, LessThan) (Zeros, Nonnegatives, Nonpositives, SecondOrderCone, RotatedSecondOrderCone, GeometricMeanCone, PositiveSemidefiniteConeTriangle, ExponentialCone) () (SingleVariable,) (ScalarAffineFunction,) (VectorOfVariables,) (VectorAffineFunction,)
+MOIU.@model SimpleModel () (EqualTo, GreaterThan, LessThan) (Zeros, Nonnegatives, Nonpositives, SecondOrderCone, RotatedSecondOrderCone, GeometricMeanCone, PositiveSemidefiniteConeTriangle, ExponentialCone) () (SingleVariable,) (ScalarAffineFunction, ScalarQuadraticFunction) (VectorOfVariables,) (VectorAffineFunction,)
 
 function test_noc(bridgedmock, F, S, n)
     @test MOI.canget(bridgedmock, MOI.NumberOfConstraints{F, S}())
@@ -159,6 +159,14 @@ end
     config = MOIT.TestConfig()
 
     @testset "Interval" begin
+        bridgedmock = MOIB.SplitInterval{Float64}(mock)
+        MOIT.basic_constraint_tests(bridgedmock, config,
+                                    include=[(MOI.SingleVariable,
+                                              MOI.Interval{Float64}),
+                                             (MOI.ScalarAffineFunction{Float64},
+                                              MOI.Interval{Float64}),
+                                             (MOI.ScalarQuadraticFunction{Float64},
+                                              MOI.Interval{Float64})])
         MOIU.set_mock_optimize!(mock,
              (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [5.0, 5.0],
                   (MOI.ScalarAffineFunction{Float64}, MOI.GreaterThan{Float64}) => [0],
@@ -168,7 +176,6 @@ end
                   (MOI.ScalarAffineFunction{Float64}, MOI.LessThan{Float64})    => [0]),
              (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [1.0, 1.0]),
              (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [6.0, 6.0]))
-        bridgedmock = MOIB.SplitInterval{Float64}(mock)
         MOIT.linear10test(bridgedmock, config)
         ci = first(MOI.get(bridgedmock, MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{Float64}, MOI.Interval{Float64}}()))
         newf = MOI.ScalarAffineFunction(MOI.ScalarAffineTerm.([1.0, -1.0], MOI.get(bridgedmock, MOI.ListOfVariableIndices())), 0.0)