Merge pull request #383 from JuliaOpt/bl/bridgeupdate

Updates to LazyBridgeOptimizers

Author: blegat

docs/src/apireference.md

@@ -311,4 +311,4 @@ Bridges.LogDetBridge
 Bridges.SOCtoPSDCBridge
 Bridges.RSOCtoPSDCBridge
 ```
-For each bridge defined in this package, a corresponding bridge optimizer is available with the same name but "Bridge" suffix, e.g. `SplitInterval` is an `SingleBridgeOptimizer` for the `SplitIntervalBridge`.
+For each bridge defined in this package, a corresponding bridge optimizer is available with the same name without the "Bridge" suffix, e.g., `SplitInterval` is an `SingleBridgeOptimizer` for the `SplitIntervalBridge`.

src/Bridges/bridge.jl

@@ -31,11 +31,11 @@ type `F`-in`S` created by the bride `b` in the model (i.e., of length equal to t
 MOI.get(b::AbstractBridge, ::MOI.ListOfConstraintIndices{F, S}) where {F, S} = CI{F, S}[]
 
 """
-    supportedconstrainttypes(BT::Type{<:AbstractBridge})::Bool
+    MOI.supportsconstraint(BT::Type{<:AbstractBridge}, F::Type{<:MOI.AbstractFunction}, S::Type{<:MOI.AbstractSet})::Bool
 
-Return a list of the types of constraints that can be bridged with a bridge of type `BT`.
+Return a `Bool` indicating whether the bridges of type `BT` support bridging `F`-in-`S` constraints.
 """
-function supportedconstrainttypes end
+MOI.supportsconstraint(::Type{<:AbstractBridge}, ::Type{<:MOI.AbstractFunction}, ::Type{<:MOI.AbstractSet}) = false
 
 """
     addedconstrainttypes(BT::Type{<:AbstractBridge}, F::Type{<:MOI.AbstractFunction}, S::Type{<:MOI.AbstractSet})::Bool

src/Bridges/detbridge.jl

@@ -85,7 +85,7 @@ function LogDetBridge{T}(model, f::MOI.VectorAffineFunction{T}, s::MOI.LogDetCon
     LogDetBridge(Δ, l, sdindex, lcindex, tlindex)
 end
 
-supportedconstrainttypes(::Type{LogDetBridge{T}}) where T = [(MOI.VectorOfVariables, MOI.LogDetConeTriangle), (MOI.VectorAffineFunction{T}, MOI.LogDetConeTriangle)]
+MOI.supportsconstraint(::Type{LogDetBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.LogDetConeTriangle}) where T = true
 addedconstrainttypes(::Type{LogDetBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.LogDetConeTriangle}) where T = [(MOI.VectorAffineFunction{T}, MOI.PositiveSemidefiniteConeTriangle), (MOI.VectorAffineFunction{T}, MOI.ExponentialCone), (MOI.ScalarAffineFunction{T}, MOI.LessThan{T})]
 
 """
@@ -177,7 +177,7 @@ function RootDetBridge{T}(model, f::MOI.VectorAffineFunction{T}, s::MOI.RootDetC
     RootDetBridge(Δ, sdindex, gmindex)
 end
 
-supportedconstrainttypes(::Type{RootDetBridge{T}}) where T = [(MOI.VectorOfVariables, MOI.RootDetConeTriangle), (MOI.VectorAffineFunction{T}, MOI.RootDetConeTriangle)]
+MOI.supportsconstraint(::Type{RootDetBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.RootDetConeTriangle}) where T = true
 addedconstrainttypes(::Type{RootDetBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.RootDetConeTriangle}) where T = [(MOI.VectorAffineFunction{T}, MOI.PositiveSemidefiniteConeTriangle), (MOI.VectorAffineFunction{T}, MOI.GeometricMeanCone)]
 
 # Attributes, Bridge acting as an model

src/Bridges/geomeanbridge.jl

@@ -91,7 +91,7 @@ function GeoMeanBridge{T}(model, f::MOI.VectorAffineFunction{T}, s::MOI.Geometri
     GeoMeanBridge(d, xij, tubc, socrc)
 end
 
-supportedconstrainttypes(::Type{GeoMeanBridge{T}}) where T = [(MOI.VectorOfVariables, MOI.GeometricMeanCone), (MOI.VectorAffineFunction{T}, MOI.GeometricMeanCone)]
+MOI.supportsconstraint(::Type{GeoMeanBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.GeometricMeanCone}) where T = true
 addedconstrainttypes(::Type{GeoMeanBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.GeometricMeanCone}) where T = [(MOI.ScalarAffineFunction{T}, MOI.LessThan{T}), (MOI.VectorAffineFunction{T}, MOI.RotatedSecondOrderCone)]
 
 # Attributes, Bridge acting as an model

src/Bridges/intervalbridge.jl

@@ -13,7 +13,7 @@ function SplitIntervalBridge{T}(model, f::MOI.ScalarAffineFunction{T}, s::MOI.In
     SplitIntervalBridge(lower, upper)
 end
 
-supportedconstrainttypes(::Type{SplitIntervalBridge{T}}) where T = [(MOI.ScalarAffineFunction{T}, MOI.Interval{T})]
+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})]
 
 # Attributes, Bridge acting as an model

src/Bridges/lazybridgeoptimizer.jl

@@ -35,24 +35,17 @@ function _dist(b::LazyBridgeOptimizer, F::Type{<:MOI.AbstractFunction}, S::Type{
     end
 end
 
-"""
-    addbridge!(b::LazyBridgeOptimizer, BT::Type{<:AbstractBridge})
-
-Enable the use of the bridges of type `BT` by `b`.
-"""
-function addbridge!(b::LazyBridgeOptimizer, BT::Type{<:AbstractBridge})
-    push!(b.bridgetypes, BT)
+# Update `b.dist` and `b.dest` for constraint types in `constraints`
+function update_dist!(b::LazyBridgeOptimizer, constraints)
     # Bellman-Ford algorithm
     changed = true # Has b.dist changed in the last iteration ?
     while changed
         changed = false
-        i = 0
         for BT in b.bridgetypes
-            i += 1
-            for (F, S) in supportedconstrainttypes(BT)
-                if all(C -> MOI.supportsconstraint(b, C...), addedconstrainttypes(BT, F, S))
+            for (F, S) in constraints
+                if MOI.supportsconstraint(BT, F, S) && all(C -> MOI.supportsconstraint(b, C[1], C[2]), addedconstrainttypes(BT, F, S))
                     # Number of bridges needed using BT
-                    dist = sum(C -> _dist(b, C...), addedconstrainttypes(BT, F, S))
+                    dist = sum(C -> _dist(b, C[1], C[2]), addedconstrainttypes(BT, F, S))
                     # Is it better that what can currently be done ?
                     if dist < _dist(b, F, S)
                         b.dist[(F, S)] = dist
@@ -65,9 +58,52 @@ function addbridge!(b::LazyBridgeOptimizer, BT::Type{<:AbstractBridge})
     end
 end
 
+function fill_required_constraints!(required::Set{Tuple{DataType, DataType}}, b::LazyBridgeOptimizer, F::Type{<:MOI.AbstractFunction}, S::Type{<:MOI.AbstractSet})
+    if MOI.supportsconstraint(b.model, F, S) || (F, S) in keys(b.best)
+        return # The constraint is supported
+    end
+    if (F, S) in required
+        return # The requirements for this constraint have already been added or are being added
+    end
+    # The constraint is not supported yet, add in `required` the required constraint types to bridge it
+    push!(required, (F, S))
+    for BT in b.bridgetypes
+        if MOI.supportsconstraint(BT, F, S)
+            for C in addedconstrainttypes(BT, F, S)
+                fill_required_constraints!(required, b, C[1], C[2])
+            end
+        end
+    end
+end
+
+# Compute dist[(F, S)] and best[(F, S)]
+function update_constraint!(b::LazyBridgeOptimizer, F::Type{<:MOI.AbstractFunction}, S::Type{<:MOI.AbstractSet})
+    required = Set{Tuple{DataType, DataType}}()
+    fill_required_constraints!(required, b, F, S)
+    update_dist!(b, required)
+end
+
+"""
+    addbridge!(b::LazyBridgeOptimizer, BT::Type{<:AbstractBridge})
+
+Enable the use of the bridges of type `BT` by `b`.
+"""
+function addbridge!(b::LazyBridgeOptimizer, BT::Type{<:AbstractBridge})
+    push!(b.bridgetypes, BT)
+    # Some constraints (F, S) in keys(b.best) may now be bridged
+    # with a less briges than `b.dist[(F, S)] using `BT`
+    update_dist!(b, keys(b.best))
+end
+
 # It only bridges when the constraint is not supporting, hence the name "Lazy"
 function isbridged(b::LazyBridgeOptimizer, F::Type{<:MOI.AbstractFunction}, S::Type{<:MOI.AbstractSet})
     !MOI.supportsconstraint(b.model, F, S)
 end
-supportsbridgingconstraint(b::LazyBridgeOptimizer, F::Type{<:MOI.AbstractFunction}, S::Type{<:MOI.AbstractSet}) = (F, S) in keys(b.best)
-bridgetype(b::LazyBridgeOptimizer{BT}, F::Type{<:MOI.AbstractFunction}, S::Type{<:MOI.AbstractSet}) where BT = b.best[(F, S)]
+function supportsbridgingconstraint(b::LazyBridgeOptimizer, F::Type{<:MOI.AbstractFunction}, S::Type{<:MOI.AbstractSet})
+    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
+    update_constraint!(b, F, S)
+    b.best[(F, S)]
+end

src/Bridges/rsocbridge.jl

@@ -35,7 +35,7 @@ function RSOCBridge{T}(model, f::MOI.VectorAffineFunction{T}, s::MOI.RotatedSeco
     RSOCBridge{T}(soc)
 end
 
-supportedconstrainttypes(::Type{RSOCBridge{T}}) where T = [(MOI.VectorOfVariables, MOI.RotatedSecondOrderCone), (MOI.VectorAffineFunction{T}, MOI.RotatedSecondOrderCone)]
+MOI.supportsconstraint(::Type{RSOCBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.RotatedSecondOrderCone}) where T = true
 addedconstrainttypes(::Type{RSOCBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.RotatedSecondOrderCone}) where T = [(MOI.VectorAffineFunction{T}, MOI.SecondOrderCone)]
 
 # Attributes, Bridge acting as an model

src/Bridges/soctopsdbridge.jl

@@ -64,7 +64,7 @@ end
 _SOCtoPSDCaff(f::MOI.VectorOfVariables, ::Type{T}) where T = _SOCtoPSDCaff(MOI.VectorAffineFunction{T}(f), T)
 _SOCtoPSDCaff(f::MOI.VectorAffineFunction, ::Type) = _SOCtoPSDCaff(f, MOIU.eachscalar(f)[1])
 
-supportedconstrainttypes(::Type{SOCtoPSDCBridge{T}}) where T = [(MOI.VectorOfVariables, MOI.SecondOrderCone), (MOI.VectorAffineFunction{T}, MOI.SecondOrderCone)]
+MOI.supportsconstraint(::Type{SOCtoPSDCBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.SecondOrderCone}) where T = true
 addedconstrainttypes(::Type{SOCtoPSDCBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.SecondOrderCone}) where T = [(MOI.VectorAffineFunction{T}, MOI.PositiveSemidefiniteConeTriangle)]
 
 function MOI.canget(instance::MOI.AbstractOptimizer, a::Union{MOI.ConstraintPrimal, MOI.ConstraintDual}, ::Type{SOCtoPSDCBridge{T}}) where T
@@ -115,7 +115,7 @@ struct RSOCtoPSDCBridge{T} <: AbstractBridge
     dim::Int
     cr::CI{MOI.VectorAffineFunction{T}, MOI.PositiveSemidefiniteConeTriangle}
 end
-supportedconstrainttypes(::Type{RSOCtoPSDCBridge{T}}) where T = [(MOI.VectorOfVariables, MOI.RotatedSecondOrderCone), (MOI.VectorAffineFunction{T}, MOI.RotatedSecondOrderCone)]
+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