Refactor modfiyconstraint!(m,c,f) to set!(m,ConstraintFunction(),c,f)

Author: odow

src/Bridges/bridgeoptimizer.jl

@@ -244,6 +244,25 @@ function MOI.set!(b::AbstractBridgeOptimizer, ::MOI.ConstraintSet, constraint_in
     end
 end
 
+function MOI.canset(b::AbstractBridgeOptimizer, ::MOI.ConstraintFunction, ::Type{C}) where C <: CI
+    if isbridged(b, C)
+       MOI.canset(b.bridged, MOI.ConstraintFunction(), C)
+        # TODO(@blegat) is this necessary? How do I do it without types
+        # && MOI.canset(b, MOIB.bridge(b, ci), change)
+    else
+        MOI.canset(b.model, MOI.ConstraintFunction(), C)
+    end
+end
+function MOI.set!(b::AbstractBridgeOptimizer, ::MOI.ConstraintFunction, constraint_index::CI, func)
+    # Note: we also under-type this function to avoid ambiguity
+    if isbridged(b, typeof(constraint_index))
+        MOI.set!(b, MOI.ConstraintFunction(), bridge(b, constraint_index), func)
+        MOI.set!(b.bridged, MOI.ConstraintFunction(), constraint_index, func)
+    else
+        MOI.set!(b.model, MOI.ConstraintFunction(), constraint_index, func)
+    end
+end
+
 # Objective
 MOI.canmodifyobjective(b::AbstractBridgeOptimizer, ::Type{M}) where M<:MOI.AbstractFunctionModification = MOI.canmodifyobjective(b.model, M)
 MOI.modifyobjective!(b::AbstractBridgeOptimizer, change::MOI.AbstractFunctionModification) = MOI.modifyobjective!(b.model, change)

src/Bridges/intervalbridge.jl

@@ -52,11 +52,17 @@ end
 
 # Constraints
 MOI.canmodifyconstraint(model::MOI.ModelLike, c::SplitIntervalBridge, change) = true
-function MOI.modifyconstraint!(model::MOI.ModelLike, c::SplitIntervalBridge, change::Union{MOI.ScalarAffineFunction, MOI.AbstractFunctionModification})
+function MOI.modifyconstraint!(model::MOI.ModelLike, c::SplitIntervalBridge, change::MOI.AbstractFunctionModification)
     MOI.modifyconstraint!(model, c.lower, change)
     MOI.modifyconstraint!(model, c.upper, change)
 end
 
+MOI.canset(model::MOI.ModelLike, ::MOI.ConstraintFunction, ::Type{<:SplitIntervalBridge}) = true
+function MOI.set!(model::MOI.ModelLike, ::MOI.ConstraintFunction, c::SplitIntervalBridge, func::MOI.ScalarAffineFunction)
+    MOI.set!(model, MOI.ConstraintFunction(), c.lower, func)
+    MOI.set!(model, MOI.ConstraintFunction(), c.upper, func)
+end
+
 MOI.canset(model::MOI.ModelLike, ::MOI.ConstraintSet, ::Type{<:SplitIntervalBridge}) = true
 function MOI.set!(model::MOI.ModelLike, ::MOI.ConstraintSet, c::SplitIntervalBridge, change::MOI.Interval)
     MOI.set!(model, MOI.ConstraintSet(), c.lower, MOI.GreaterThan(change.lower))

src/Utilities/cachingoptimizer.jl

@@ -271,6 +271,30 @@ function MOI.set!(m::CachingOptimizer, ::MOI.ConstraintSet, cindex::CI{F,S}, set
     return
 end
 
+function MOI.canset(m::CachingOptimizer, ::MOI.ConstraintFunction, ::Type{C}) where C <: CI
+    if !MOI.canset(m.model_cache, MOI.ConstraintFunction(), C)
+        return false
+    end
+    if m.state == AttachedOptimizer && m.mode == Manual
+        if !MOI.canset(m.optimizer, MOI.ConstraintFunction(), C)
+            return false
+        end
+    end
+    return true
+end
+function MOI.set!(m::CachingOptimizer, ::MOI.ConstraintFunction, cindex::CI{F,S}, func::F) where {F<:MOI.AbstractFunction, S<:MOI.AbstractSet}
+    if (m.mode == Automatic && m.state == AttachedOptimizer &&
+            !MOI.canset(m.optimizer, MOI.ConstraintFunction(), typeof(cindex)) )
+        resetoptimizer!(m)
+    end
+    @assert MOI.canset(m, MOI.ConstraintFunction(), typeof(cindex))
+    MOI.set!(m.model_cache, MOI.ConstraintFunction(), cindex, func)
+    if m.state == AttachedOptimizer
+        MOI.set!(m.optimizer, MOI.ConstraintFunction(), m.model_to_optimizer_map[cindex], func)
+    end
+    return
+end
+
 function MOI.canmodifyobjective(m::CachingOptimizer, change)
     MOI.canmodifyobjective(m.model_cache, change) || return false
     if m.state == AttachedOptimizer && m.mode == Manual

src/Utilities/mockoptimizer.jl

@@ -215,6 +215,11 @@ function MOI.set!(mock::MockOptimizer, ::MOI.ConstraintSet, c::CI{F,S}, set::S)
     MOI.set!(mock.inner_model, MOI.ConstraintSet(), xor_index(c), set)
 end
 
+MOI.canset(mock::MockOptimizer, ::MOI.ConstraintFunction, ::Type{C}) where C <: CI = true
+function MOI.set!(mock::MockOptimizer, ::MOI.ConstraintFunction, c::CI{F,S}, func::F) where {F<:MOI.AbstractFunction, S<:MOI.AbstractSet}
+    MOI.set!(mock.inner_model, MOI.ConstraintFunction(), xor_index(c), func)
+end
+
 function MOI.canmodifyobjective(mock::MockOptimizer, change)
     MOI.canmodifyobjective(mock.inner_model, change)
 end

src/Utilities/model.jl

@@ -257,10 +257,10 @@ MOI.canmodifyconstraint(::AbstractModel, ::CI, ::Type{<:MOI.AbstractFunction}) =
 function MOI.modifyconstraint!(model::AbstractModel, ci::CI, change::MOI.AbstractFunction)
     _modifyconstraint!(model, ci, getconstrloc(model, ci), change)
 end
-# MOI.canset(::AbstractModel, ::MOI.ConstraintFunction, ::Type{<:CI}) = true
-# function MOI.set!(model::AbstractModel, ::MOI.ConstraintFunction, ci::CI, change::MOI.AbstractFunction)
-#     _modifyconstraint!(model, ci, getconstrloc(model, ci), change)
-# end
+MOI.canset(::AbstractModel, ::MOI.ConstraintFunction, ::Type{<:CI}) = true
+function MOI.set!(model::AbstractModel, ::MOI.ConstraintFunction, ci::CI, change::MOI.AbstractFunction)
+    _modifyconstraint!(model, ci, getconstrloc(model, ci), change)
+end
 MOI.canset(::AbstractModel, ::MOI.ConstraintSet, ::Type{<:CI}) = true
 function MOI.set!(model::AbstractModel, ::MOI.ConstraintSet, ci::CI, change::MOI.AbstractSet)
     _modifyconstraint!(model, ci, getconstrloc(model, ci), change)

src/Utilities/universalfallback.jl

@@ -162,6 +162,12 @@ function MOI.set!(uf::UniversalFallback, ::MOI.ConstraintSet, ci::CI{F,S}, set::
     MOI.set!(uf.model, MOI.ConstraintSet(), ci, set)
 end
 
+function MOI.canset(uf::UniversalFallback, ::MOI.ConstraintFunction, ::Type{C}) where C <: CI
+    MOI.canset(uf.model, MOI.ConstraintFunction(), C)
+end
+function MOI.set!(uf::UniversalFallback, ::MOI.ConstraintFunction, ci::CI{F,S}, func::F) where F where S
+    MOI.set!(uf.model, MOI.ConstraintFunction(), ci, func)
+end
 
 # Objective
 MOI.canmodifyobjective(uf::UniversalFallback, ::Type{M}) where M<:MOI.AbstractFunctionModification = MOI.canmodifyobjective(uf.model, M)

src/constraints.jl

@@ -43,7 +43,6 @@ function addconstraints! end
 # default fallback
 addconstraints!(model::ModelLike, funcs, sets) = addconstraint!.(model, funcs, sets)
 
-
 """
     canset(model::ModelLike, ::ConstraintSet, ::Type{ConstraintIndex{F,S}})::Bool
 
@@ -84,43 +83,55 @@ end
 set_type(c::ConstraintIndex{F,S}) where {F, S} = S
 
 """
-## Modify Function
-
-    canmodifyconstraint(model::ModelLike, c::ConstraintIndex{F,S}, ::Type{F})::Bool
+    canset(model::ModelLike, ::ConstraintFunction, ::Type{ConstraintIndex{F,S}})::Bool
 
-Return a `Bool` indicating whether the function in constraint `c` can be replaced by another function of the same type `F` as the original function.
-
-## Partial Modifications
+Return a `Bool` indicating whether the function in a constraint of type
+`F`-in-`S` can be replaced by another set of the same type `F` as the original
+function.
+"""
+canset(model::ModelLike, ::ConstraintFunction, type_of_function) = false
+# Note: the above method is deliberately under-typed to avoid method ambiguities
 
-    canmodifyconstraint(model::ModelLike, c::ConstraintIndex, ::Type{M})::Bool where M<:AbstractFunctionModification
+"""
+    set!(model::ModelLike, ::ConstraintFunction, c::ConstraintIndex{F,S}, func::F)
 
-Return a `Bool` indicating whether it is possible to apply a modification of type `M` to the function of constraint `c`.
+Replace the function in constraint `c` with `func`. `F` must match the original
+function type used to define the constraint.
 
 ### Examples
 
+If `c` is a `ConstraintIndex{ScalarAffineFunction,S}` and `v1` and `v2` are
+`VariableIndex` objects,
+
 ```julia
-canmodifyconstraint(model, c, ScalarConstantChange{Float64})
+set!(model, ConstraintFunction(), c, ScalarAffineFunction([v1,v2],[1.0,2.0],5.0))
+set!(model, ConstraintFunction(), c, SingleVariable(v1)) # Error
 ```
 """
-function canmodifyconstraint end
-canmodifyconstraint(model::ModelLike, c::ConstraintIndex, change) = false
+function set!(model::ModelLike, ::ConstraintFunction, constraint_index, func)
+    # note: we deliberately avoid typing the last two arguments to avoid
+    # ambiguity errors. If solvers don't catch the case where the set is
+    # different, it should still fall back to this method.
+    throw(MethodError(set!, (model, ConstraintFunction(), constraint_index, func)))
+end
 
 """
-## Modify Function
+## Partial Modifications
 
-    modifyconstraint!(model::ModelLike, c::ConstraintIndex{F,S}, func::F)
+    canmodifyconstraint(model::ModelLike, c::ConstraintIndex, ::Type{M})::Bool where M<:AbstractFunctionModification
 
-Replace the function in constraint `c` with `func`. `F` must match the original function type used to define the constraint.
+Return a `Bool` indicating whether it is possible to apply a modification of type `M` to the function of constraint `c`.
 
 ### Examples
 
-If `c` is a `ConstraintIndex{ScalarAffineFunction,S}` and `v1` and `v2` are `VariableIndex` objects,
-
 ```julia
-modifyconstraint!(model, c, ScalarAffineFunction([v1,v2],[1.0,2.0],5.0))
-modifyconstraint!(model, c, SingleVariable(v1)) # Error
+canmodifyconstraint(model, c, ScalarConstantChange{Float64})
 ```
+"""
+function canmodifyconstraint end
+canmodifyconstraint(model::ModelLike, c::ConstraintIndex, change) = false
 
+"""
 ## Partial Modifications
 
     modifyconstraint!(model::ModelLike, c::ConstraintIndex, change::AbstractFunctionModification)

test/bridge.jl

@@ -167,7 +167,7 @@ end
         ci = first(MOI.get(bridgedmock, MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{Float64}, MOI.Interval{Float64}}()))
         @test MOI.canmodifyconstraint(bridgedmock, ci, MOI.ScalarAffineFunction{Float64})
         newf = MOI.ScalarAffineFunction(MOI.ScalarAffineTerm.([1.0, -1.0], MOI.get(bridgedmock, MOI.ListOfVariableIndices())), 0.0)
-        MOI.modifyconstraint!(bridgedmock, ci, newf)
+        MOI.set!(bridgedmock, MOI.ConstraintFunction(), ci, newf)
         @test MOI.canget(bridgedmock, MOI.ConstraintFunction(), typeof(ci))
         @test MOI.get(bridgedmock, MOI.ConstraintFunction(), ci) ≈ newf
         test_delete_bridge(bridgedmock, ci, 2, ((MOI.ScalarAffineFunction{Float64}, MOI.GreaterThan{Float64}, 0),

test/model.jl

@@ -62,8 +62,7 @@ end
     f3 = MOIU.modifyfunction(f3, MOI.ScalarCoefficientChange(y, 2))
 
     @test !(MOI.get(model, MOI.ConstraintFunction(), c1) ≈ f3)
-    MOI.modifyconstraint!(model, c1, f3)
-    # MOI.set!(model, MOI.ConstraintFunction(), c1, f3)
+    MOI.set!(model, MOI.ConstraintFunction(), c1, f3)
     @test MOI.get(model, MOI.ConstraintFunction(), c1) ≈ f3
 
     f4 = MOI.VectorAffineFunction(MOI.VectorAffineTerm.([1, 1, 2], MOI.ScalarAffineTerm.([2, 4, 3], [x, y, y])), [5, 7])