Refactor modifyconstraint! to modify! and canmodifycontraint to

canmodify. These functions now only apply to
AbstractFunctionModification changes.

Author: odow

docs/src/apimanual.md

@@ -531,7 +531,7 @@ See [`PositiveSemidefiniteConeTriangle`](@ref MathOptInterface.PositiveSemidefin
 
 ### Modifying a model
 
-[Explain `modifyconstraint!` and `modifyobjective!`.]
+[Explain `modify!` and `modifyobjective!`.]
 
 ### Constraint bridges
 

docs/src/apireference.md

@@ -163,8 +163,8 @@ isvalid(::ModelLike,::ConstraintIndex)
 canaddconstraint
 addconstraint!
 addconstraints!
-modifyconstraint!
-canmodifyconstraint
+modify!
+canmodify
 transformconstraint!
 cantransformconstraint
 supportsconstraint

src/Bridges/bridgeoptimizer.jl

@@ -209,19 +209,19 @@ function MOI.addconstraint!(b::AbstractBridgeOptimizer, f::MOI.AbstractFunction,
         MOI.addconstraint!(b.model, f, s)
     end
 end
-function MOI.canmodifyconstraint(b::AbstractBridgeOptimizer, ci::CI, change)
+function MOI.canmodify(b::AbstractBridgeOptimizer, ci::CI, change)
     if isbridged(b, typeof(ci))
-       MOI.canmodifyconstraint(b.bridged, ci, change) && MOI.canmodifyconstraint(b, MOIB.bridge(b, ci), change)
+       MOI.canmodify(b.bridged, ci, change) && MOI.canmodify(b, MOIB.bridge(b, ci), change)
     else
-        MOI.canmodifyconstraint(b.model, ci, change)
+        MOI.canmodify(b.model, ci, change)
     end
 end
-function MOI.modifyconstraint!(b::AbstractBridgeOptimizer, ci::CI, change)
+function MOI.modify!(b::AbstractBridgeOptimizer, ci::CI, change)
     if isbridged(b, typeof(ci))
-        MOI.modifyconstraint!(b, bridge(b, ci), change)
-        MOI.modifyconstraint!(b.bridged, ci, change)
+        MOI.modify!(b, bridge(b, ci), change)
+        MOI.modify!(b.bridged, ci, change)
     else
-        MOI.modifyconstraint!(b.model, ci, change)
+        MOI.modify!(b.model, ci, change)
     end
 end
 

src/Bridges/detbridge.jl

@@ -141,7 +141,7 @@ end
 MOI.canget(model::MOI.ModelLike, a::MOI.ConstraintDual, ::Type{<:LogDetBridge}) = false
 
 # Constraints
-MOI.canmodifyconstraint(model::MOI.ModelLike, c::LogDetBridge, change) = false
+MOI.canmodify(model::MOI.ModelLike, c::LogDetBridge, change) = false
 
 """
     RootDetBridge{T}
@@ -207,4 +207,4 @@ end
 MOI.canget(model::MOI.ModelLike, ::MOI.ConstraintDual, ::Type{<:RootDetBridge}) = false
 
 # Constraints
-MOI.canmodifyconstraint(model::MOI.ModelLike, c::RootDetBridge, change) = false
+MOI.canmodify(model::MOI.ModelLike, c::RootDetBridge, change) = false

src/Bridges/geomeanbridge.jl

@@ -138,4 +138,4 @@ MOI.canget(model::MOI.ModelLike, a::MOI.ConstraintDual, ::Type{<:GeoMeanBridge})
 #end
 
 # Constraints
-MOI.canmodifyconstraint(model::MOI.ModelLike, c::GeoMeanBridge, change) = false
+MOI.canmodify(model::MOI.ModelLike, c::GeoMeanBridge, change) = false

src/Bridges/intervalbridge.jl

@@ -51,10 +51,10 @@ function MOI.get(model::MOI.ModelLike, a::MOI.ConstraintDual, c::SplitIntervalBr
 end
 
 # Constraints
-MOI.canmodifyconstraint(model::MOI.ModelLike, c::SplitIntervalBridge, change) = true
-function MOI.modifyconstraint!(model::MOI.ModelLike, c::SplitIntervalBridge, change::MOI.AbstractFunctionModification)
-    MOI.modifyconstraint!(model, c.lower, change)
-    MOI.modifyconstraint!(model, c.upper, change)
+MOI.canmodify(model::MOI.ModelLike, c::SplitIntervalBridge, change) = true
+function MOI.modify!(model::MOI.ModelLike, c::SplitIntervalBridge, change::MOI.AbstractFunctionModification)
+    MOI.modify!(model, c.lower, change)
+    MOI.modify!(model, c.upper, change)
 end
 
 MOI.canset(model::MOI.ModelLike, ::MOI.ConstraintFunction, ::Type{<:SplitIntervalBridge}) = true

src/Bridges/rsocbridge.jl

@@ -66,4 +66,4 @@ end
 MOI.get(model::MOI.ModelLike, attr::MOI.ConstraintDual, c::RSOCBridge) = _get(model, attr, c)
 
 # Constraints
-MOI.canmodifyconstraint(model::MOI.ModelLike, c::RSOCBridge, change) = false
+MOI.canmodify(model::MOI.ModelLike, c::RSOCBridge, change) = false

src/Bridges/soctopsdbridge.jl

@@ -86,7 +86,7 @@ function MOI.delete!(instance::MOI.AbstractOptimizer, c::SOCtoPSDCBridge)
     MOI.delete!(instance, c.cr)
 end
 
-MOI.canmodifyconstraint(::MOI.AbstractOptimizer, ::SOCtoPSDCBridge, change) = false
+MOI.canmodify(::MOI.AbstractOptimizer, ::SOCtoPSDCBridge, change) = false
 
 """
 The `RSOCtoPSDCBridge` transforms the second order cone constraint ``\\lVert x \\rVert \\le 2tu`` with ``u \\ge 0`` into the semidefinite cone constraints
@@ -151,4 +151,4 @@ function MOI.delete!(instance::MOI.AbstractOptimizer, c::RSOCtoPSDCBridge)
     MOI.delete!(instance, c.cr)
 end
 
-MOI.canmodifyconstraint(::MOI.AbstractOptimizer, ::RSOCtoPSDCBridge, change) = false
+MOI.canmodify(::MOI.AbstractOptimizer, ::RSOCtoPSDCBridge, change) = false

src/Test/contlinear.jl

@@ -172,8 +172,8 @@ function linear1test(model::MOI.ModelLike, config::TestConfig)
     @test MOI.get(model, MOI.NumberOfConstraints{MOI.SingleVariable,MOI.GreaterThan{Float64}}()) == 3
 
     if config.modify_lhs
-        @test MOI.canmodifyconstraint(model, c, MOI.ScalarCoefficientChange{Float64})
-        MOI.modifyconstraint!(model, c, MOI.ScalarCoefficientChange{Float64}(z, 1.0))
+        @test MOI.canmodify(model, c, MOI.ScalarCoefficientChange{Float64})
+        MOI.modify!(model, c, MOI.ScalarCoefficientChange{Float64}(z, 1.0))
     else
         @test MOI.candelete(model, c)
         MOI.delete!(model, c)
@@ -781,8 +781,8 @@ function linear5test(model::MOI.ModelLike, config::TestConfig)
     #   solution: x = 2, y = 0, objv = 2
 
     if config.modify_lhs
-        @test MOI.canmodifyconstraint(model, c1, MOI.ScalarCoefficientChange{Float64})
-        MOI.modifyconstraint!(model, c1, MOI.ScalarCoefficientChange(y, 3.0))
+        @test MOI.canmodify(model, c1, MOI.ScalarCoefficientChange{Float64})
+        MOI.modify!(model, c1, MOI.ScalarCoefficientChange(y, 3.0))
     else
         @test MOI.candelete(model, c1)
         MOI.delete!(model, c1)
@@ -980,8 +980,8 @@ function linear7test(model::MOI.ModelLike, config::TestConfig)
     #               y <= 0.0
 
     if config.modify_lhs
-        @test MOI.canmodifyconstraint(model, c1, MOI.VectorConstantChange{Float64})
-        MOI.modifyconstraint!(model, c1, MOI.VectorConstantChange([-100.0]))
+        @test MOI.canmodify(model, c1, MOI.VectorConstantChange{Float64})
+        MOI.modify!(model, c1, MOI.VectorConstantChange([-100.0]))
     else
         @test MOI.candelete(model, c1)
         MOI.delete!(model, c1)
@@ -1004,8 +1004,8 @@ function linear7test(model::MOI.ModelLike, config::TestConfig)
     #               y <= -100.0
 
     if config.modify_lhs
-        @test MOI.canmodifyconstraint(model, c2, MOI.VectorConstantChange{Float64})
-        MOI.modifyconstraint!(model, c2, MOI.VectorConstantChange([100.0]))
+        @test MOI.canmodify(model, c2, MOI.VectorConstantChange{Float64})
+        MOI.modify!(model, c2, MOI.VectorConstantChange([100.0]))
     else
         @test MOI.candelete(model, c2)
         MOI.delete!(model, c2)

src/Utilities/cachingoptimizer.jl

@@ -227,22 +227,22 @@ function MOI.addconstraint!(m::CachingOptimizer, func::MOI.AbstractFunction, set
     return cindex
 end
 
-function MOI.canmodifyconstraint(m::CachingOptimizer, cindex::CI, change)
-    MOI.canmodifyconstraint(m.model_cache, cindex, change) || return false
+function MOI.canmodify(m::CachingOptimizer, cindex::CI, change)
+    MOI.canmodify(m.model_cache, cindex, change) || return false
     if m.state == AttachedOptimizer && m.mode == Manual
-        MOI.canmodifyconstraint(m.optimizer, m.model_to_optimizer_map[cindex], change) || return false
+        MOI.canmodify(m.optimizer, m.model_to_optimizer_map[cindex], change) || return false
     end
     return true
 end
 
-function MOI.modifyconstraint!(m::CachingOptimizer, cindex::CI, change)
-    if m.mode == Automatic && m.state == AttachedOptimizer && !MOI.canmodifyconstraint(m.optimizer, cindex, typeof(change))
+function MOI.modify!(m::CachingOptimizer, cindex::CI, change)
+    if m.mode == Automatic && m.state == AttachedOptimizer && !MOI.canmodify(m.optimizer, cindex, typeof(change))
         resetoptimizer!(m)
     end
-    @assert MOI.canmodifyconstraint(m, cindex, typeof(change))
-    MOI.modifyconstraint!(m.model_cache, cindex, change)
+    @assert MOI.canmodify(m, cindex, typeof(change))
+    MOI.modify!(m.model_cache, cindex, change)
     if m.state == AttachedOptimizer
-        MOI.modifyconstraint!(m.optimizer, m.model_to_optimizer_map[cindex], mapvariables(m.model_to_optimizer_map,change))
+        MOI.modify!(m.optimizer, m.model_to_optimizer_map[cindex], mapvariables(m.model_to_optimizer_map,change))
     end
     return
 end

src/Utilities/mockoptimizer.jl

@@ -202,12 +202,12 @@ function MOI.delete!(mock::MockOptimizer, idx::MOI.ConstraintIndex)
     MOI.delete!(mock.condual, idx)
 end
 
-function MOI.canmodifyconstraint(mock::MockOptimizer, c::CI, change)
-    MOI.canmodifyconstraint(mock.inner_model, xor_index(c), change)
+function MOI.canmodify(mock::MockOptimizer, c::CI, change)
+    MOI.canmodify(mock.inner_model, xor_index(c), change)
 end
 
-function MOI.modifyconstraint!(mock::MockOptimizer, c::CI, change)
-    MOI.modifyconstraint!(mock.inner_model, xor_index(c), xor_variables(change))
+function MOI.modify!(mock::MockOptimizer, c::CI, change)
+    MOI.modify!(mock.inner_model, xor_index(c), xor_variables(change))
 end
 
 MOI.canset(mock::MockOptimizer, ::MOI.ConstraintSet, ::Type{C}) where C <: CI = true

src/Utilities/model.jl

@@ -33,7 +33,7 @@ end
 _modifyconstr(ci::CI{F, S}, f::F, s::S, change::F) where {F, S} = (ci, change, s)
 _modifyconstr(ci::CI{F, S}, f::F, s::S, change::S) where {F, S} = (ci, f, change)
 _modifyconstr(ci::CI{F, S}, f::F, s::S, change::MOI.AbstractFunctionModification) where {F, S} = (ci, modifyfunction(f, change), s)
-function _modifyconstraint!(constrs::Vector{C{F, S}}, ci::CI{F}, i::Int, change) where {F, S}
+function _modify!(constrs::Vector{C{F, S}}, ci::CI{F}, i::Int, change) where {F, S}
     constrs[i] = _modifyconstr(constrs[i]..., change)
 end
 
@@ -248,22 +248,22 @@ function MOI.delete!(model::AbstractModel, ci::CI)
     end
 end
 
-MOI.canmodifyconstraint(::AbstractModel, ::CI, ::Type{<:MOI.AbstractFunctionModification}) = true
-function MOI.modifyconstraint!(model::AbstractModel, ci::CI, change::MOI.AbstractFunctionModification)
-    _modifyconstraint!(model, ci, getconstrloc(model, ci), change)
+MOI.canmodify(::AbstractModel, ::CI, ::Type{<:MOI.AbstractFunctionModification}) = true
+function MOI.modify!(model::AbstractModel, ci::CI, change::MOI.AbstractFunctionModification)
+    _modify!(model, ci, getconstrloc(model, ci), change)
 end
 
-MOI.canmodifyconstraint(::AbstractModel, ::CI, ::Type{<:MOI.AbstractFunction}) = true
-function MOI.modifyconstraint!(model::AbstractModel, ci::CI, change::MOI.AbstractFunction)
-    _modifyconstraint!(model, ci, getconstrloc(model, ci), change)
+MOI.canmodify(::AbstractModel, ::CI, ::Type{<:MOI.AbstractFunction}) = true
+function MOI.modify!(model::AbstractModel, ci::CI, change::MOI.AbstractFunction)
+    _modify!(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)
+    _modify!(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)
+    _modify!(model, ci, getconstrloc(model, ci), change)
 end
 
 MOI.get(model::AbstractModel, noc::MOI.NumberOfConstraints) = _getnoc(model, noc)
@@ -547,7 +547,7 @@ macro model(modelname, ss, sst, vs, vst, sf, sft, vf, vft)
         end
     end
 
-    for (func, T) in ((:_addconstraint!, CI), (:_modifyconstraint!, CI), (:_delete!, CI), (:_getindex, CI), (:_getfunction, CI), (:_getset, CI), (:_getnoc, MOI.NumberOfConstraints))
+    for (func, T) in ((:_addconstraint!, CI), (:_modify!, CI), (:_delete!, CI), (:_getindex, CI), (:_getfunction, CI), (:_getset, CI), (:_getnoc, MOI.NumberOfConstraints))
         funct = _mod(MOIU, func)
         for (c, sets) in ((scname, scalarsets), (vcname, vectorsets))
             for s in sets

src/Utilities/universalfallback.jl

@@ -152,8 +152,8 @@ end
 MOI.supportsconstraint(uf::UniversalFallback, ::Type{F}, ::Type{S}) where {F<:MOI.AbstractFunction, S<:MOI.AbstractSet} = true
 MOI.canaddconstraint(uf::UniversalFallback, ::Type{F}, ::Type{S}) where {F<:MOI.AbstractFunction, S<:MOI.AbstractSet} = MOI.canaddconstraint(uf.model, F, S)
 MOI.addconstraint!(uf::UniversalFallback, f::MOI.AbstractFunction, s::MOI.AbstractSet) = MOI.addconstraint!(uf.model, f, s)
-MOI.canmodifyconstraint(uf::UniversalFallback, ci::CI, change) = MOI.canmodifyconstraint(uf.model, ci, change)
-MOI.modifyconstraint!(uf::UniversalFallback, ci::CI, change) = MOI.modifyconstraint!(uf.model, ci, change)
+MOI.canmodify(uf::UniversalFallback, ci::CI, change) = MOI.canmodify(uf.model, ci, change)
+MOI.modify!(uf::UniversalFallback, ci::CI, change) = MOI.modify!(uf.model, ci, change)
 
 function MOI.canset(uf::UniversalFallback, ::MOI.ConstraintSet, ::Type{C}) where C <: CI
     MOI.canset(uf.model, MOI.ConstraintSet(), C)

src/constraints.jl

@@ -118,33 +118,33 @@ end
 """
 ## Partial Modifications
 
-    canmodifyconstraint(model::ModelLike, c::ConstraintIndex, ::Type{M})::Bool where M<:AbstractFunctionModification
+    canmodify(model::ModelLike, c::ConstraintIndex, ::Type{M})::Bool where M<:AbstractFunctionModification
 
 Return a `Bool` indicating whether it is possible to apply a modification of type `M` to the function of constraint `c`.
 
 ### Examples
 
 ```julia
-canmodifyconstraint(model, c, ScalarConstantChange{Float64})
+canmodify(model, c, ScalarConstantChange{Float64})
 ```
 """
-function canmodifyconstraint end
-canmodifyconstraint(model::ModelLike, c::ConstraintIndex, change) = false
+function canmodify end
+canmodify(model::ModelLike, c::ConstraintIndex, change) = false
 
 """
 ## Partial Modifications
 
-    modifyconstraint!(model::ModelLike, c::ConstraintIndex, change::AbstractFunctionModification)
+    modify!(model::ModelLike, c::ConstraintIndex, change::AbstractFunctionModification)
 
 Apply the modification specified by `change` to the function of constraint `c`.
 
 ### Examples
 
 ```julia
-modifyconstraint!(model, c, ScalarConstantChange(10.0))
+modify!(model, c, ScalarConstantChange(10.0))
 ```
 """
-function modifyconstraint! end
+function modify! end
 
 
 """
@@ -159,7 +159,7 @@ the correct type.
 Solvers may only support a subset of constraint transforms that they perform
 efficiently (for example, changing from a `LessThan` to `GreaterThan` set). In
 addition, set modification (where `S1 = S2`) should be performed via the
-`modifyconstraint!` function.
+`modify!` function.
 
 
 Typically, the user should delete the constraint and add a new one.