Refactor modifyobjective! to modify!(m, ObjectiveFunction, change).

Author: odow

docs/src/apimanual.md

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

docs/src/apireference.md

@@ -255,8 +255,8 @@ dimension
 Functions for modifying objective functions. Use `ObjectiveFunction` and `ObjectiveSense` to set and query the objective function.
 
 ```@docs
-modifyobjective!
-canmodifyobjective
+modify!
+canmodify
 ```
 
 ## Nonlinear programming (NLP)

src/Bridges/bridgeoptimizer.jl

@@ -266,8 +266,8 @@ function MOI.set!(b::AbstractBridgeOptimizer, ::MOI.ConstraintFunction, constrai
 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)
+MOI.canmodify(b::AbstractBridgeOptimizer, obj::MOI.ObjectiveFunction, ::Type{M}) where M<:MOI.AbstractFunctionModification = MOI.canmodify(b.model, obj, M)
+MOI.modify!(b::AbstractBridgeOptimizer, obj::MOI.ObjectiveFunction, change::MOI.AbstractFunctionModification) = MOI.modify!(b.model, obj, change)
 
 # Variables
 MOI.canaddvariable(b::AbstractBridgeOptimizer) = MOI.canaddvariable(b.model)

src/MathOptInterface.jl

@@ -152,7 +152,7 @@ include("functions.jl")
 include("sets.jl")
 include("attributes.jl")
 include("constraints.jl")
-include("objectives.jl")
+include("modifications.jl")
 include("variables.jl")
 include("nlp.jl")
 

src/Test/contlinear.jl

@@ -182,8 +182,14 @@ function linear1test(model::MOI.ModelLike, config::TestConfig)
         c = MOI.addconstraint!(model, cf, MOI.LessThan(1.0))
     end
 
-    @test MOI.canmodifyobjective(model, MOI.ScalarCoefficientChange{Float64})
-    MOI.modifyobjective!(model, MOI.ScalarCoefficientChange{Float64}(z, 2.0))
+    @test MOI.canmodify(model,
+        MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}(),
+        MOI.ScalarCoefficientChange{Float64}
+    )
+    MOI.modify!(model,
+        MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}(),
+        MOI.ScalarCoefficientChange{Float64}(z, 2.0)
+    )
 
     @test MOI.get(model, MOI.NumberOfConstraints{MOI.ScalarAffineFunction{Float64},MOI.LessThan{Float64}}()) == 1
     @test MOI.get(model, MOI.NumberOfConstraints{MOI.SingleVariable,MOI.GreaterThan{Float64}}()) == 3

src/Utilities/cachingoptimizer.jl

@@ -295,22 +295,22 @@ function MOI.set!(m::CachingOptimizer, ::MOI.ConstraintFunction, cindex::CI{F,S}
     return
 end
 
-function MOI.canmodifyobjective(m::CachingOptimizer, change)
-    MOI.canmodifyobjective(m.model_cache, change) || return false
+function MOI.canmodify(m::CachingOptimizer, obj::MOI.ObjectiveFunction, change)
+    MOI.canmodify(m.model_cache, obj, change) || return false
     if m.state == AttachedOptimizer && m.mode == Manual
-        MOI.canmodifyobjective(m.optimizer, change) || return false
+        MOI.canmodify(m.optimizer, obj, change) || return false
     end
     return true
 end
 
-function MOI.modifyobjective!(m::CachingOptimizer, change::MOI.AbstractFunctionModification)
-    if m.mode == Automatic && m.state == AttachedOptimizer && !MOI.canmodifyobjective(m.optimizer, typeof(change))
+function MOI.modify!(m::CachingOptimizer, obj::MOI.ObjectiveFunction, change::MOI.AbstractFunctionModification)
+    if m.mode == Automatic && m.state == AttachedOptimizer && !MOI.canmodify(m.optimizer, obj, typeof(change))
         resetoptimizer!(m)
     end
-    @assert MOI.canmodifyobjective(m, typeof(change))
-    MOI.modifyobjective!(m.model_cache, change)
+    @assert MOI.canmodify(m, obj, typeof(change))
+    MOI.modify!(m.model_cache, obj, change)
     if m.state == AttachedOptimizer
-        MOI.modifyobjective!(m.optimizer, mapvariables(m.model_to_optimizer_map,change))
+        MOI.modify!(m.optimizer, obj, mapvariables(m.model_to_optimizer_map,change))
     end
     return
 end

src/Utilities/mockoptimizer.jl

@@ -219,12 +219,12 @@ function MOI.set!(mock::MockOptimizer, ::MOI.ConstraintFunction, c::CI{F,S}, fun
     MOI.set!(mock.inner_model, MOI.ConstraintFunction(), xor_index(c), func)
 end
 
-function MOI.canmodifyobjective(mock::MockOptimizer, change)
-    MOI.canmodifyobjective(mock.inner_model, change)
+function MOI.canmodify(mock::MockOptimizer, obj::MOI.ObjectiveFunction, change)
+    MOI.canmodify(mock.inner_model, obj, change)
 end
 
-function MOI.modifyobjective!(mock::MockOptimizer, change::MOI.AbstractFunctionModification)
-    MOI.modifyobjective!(mock.inner_model, xor_variables(change))
+function MOI.modify!(mock::MockOptimizer, obj::MOI.ObjectiveFunction, change::MOI.AbstractFunctionModification)
+    MOI.modify!(mock.inner_model, obj, xor_variables(change))
 end
 
 # TODO: transformconstraint and cantransformconstraint

src/Utilities/model.jl

@@ -203,8 +203,8 @@ function MOI.set!(model::AbstractModel, ::MOI.ObjectiveFunction, f::MOI.Abstract
     model.objective = deepcopy(f)
 end
 
-MOI.canmodifyobjective(::AbstractModel, ::Type{<:MOI.AbstractFunctionModification}) = true
-function MOI.modifyobjective!(model::AbstractModel, change::MOI.AbstractFunctionModification)
+MOI.canmodify(::AbstractModel, ::MOI.ObjectiveFunction, ::Type{<:MOI.AbstractFunctionModification}) = true
+function MOI.modify!(model::AbstractModel, obj::MOI.ObjectiveFunction, change::MOI.AbstractFunctionModification)
     model.objective = modifyfunction(model.objective, change)
 end
 

src/Utilities/universalfallback.jl

@@ -170,8 +170,8 @@ function MOI.set!(uf::UniversalFallback, ::MOI.ConstraintFunction, ci::CI{F,S},
 end
 
 # Objective
-MOI.canmodifyobjective(uf::UniversalFallback, ::Type{M}) where M<:MOI.AbstractFunctionModification = MOI.canmodifyobjective(uf.model, M)
-MOI.modifyobjective!(uf::UniversalFallback, change::MOI.AbstractFunctionModification) = MOI.modifyobjective!(uf.model, change)
+MOI.canmodify(uf::UniversalFallback, obj::MOI.ObjectiveFunction, ::Type{M}) where M<:MOI.AbstractFunctionModification = MOI.canmodify(uf.model, obj, M)
+MOI.modify!(uf::UniversalFallback, obj::MOI.ObjectiveFunction, change::MOI.AbstractFunctionModification) = MOI.modify!(uf.model, obj, change)
 
 # Variables
 MOI.canaddvariable(uf::UniversalFallback) = MOI.canaddvariable(uf.model)

src/constraints.jl

@@ -115,35 +115,6 @@ function set!(model::ModelLike, ::ConstraintFunction, constraint_index, func)
     throw(MethodError(set!, (model, ConstraintFunction(), constraint_index, func)))
 end
 
-"""
-    canmodify(model::ModelLike, ::Type{CI}, ::Type{M})::Bool where CI<:ConstraintIndex where M<:AbstractFunctionModification
-
-Return a `Bool` indicating whether it is possible to apply a modification of
-type `M` to the function of constraint of type `CI`.
-
-### Examples
-
-```julia
-canmodify(model, MOI.ConstraintIndex{MOI.ScalarAffineFunction{Float64}, MOI.LessThan{Float64}}, ScalarConstantChange{Float64})
-```
-"""
-function canmodify end
-canmodify(model::ModelLike, constraint_index, change) = false
-
-"""
-    modify!(model::ModelLike, c::ConstraintIndex, change::AbstractFunctionModification)
-
-Apply the modification specified by `change` to the function of constraint `c`.
-
-### Examples
-
-```julia
-modify!(model, c, ScalarConstantChange(10.0))
-```
-"""
-function modify! end
-
-
 """
 ## Transform Constraint Set
 

src/modifications.jl

@@ -0,0 +1,56 @@
+"""
+## Constraint Function
+    canmodify(model::ModelLike, ::Type{CI}, ::Type{M})::Bool where CI<:ConstraintIndex where M<:AbstractFunctionModification
+
+Return a `Bool` indicating whether it is possible to apply a modification of
+type `M` to the function of constraint of type `CI`.
+
+### Examples
+
+```julia
+canmodify(model, MOI.ConstraintIndex{MOI.ScalarAffineFunction{Float64}, MOI.LessThan{Float64}}, ScalarConstantChange{Float64})
+```
+
+## Objective Function
+
+canmodify(model::ModelLike, ::ObjectiveFunction, ::Type{M})::Bool where M<:AbstractFunctionModification
+
+Return a `Bool` indicating whether it is possible to apply a modification of
+type `M` to the objective function of model `model`.
+
+### Examples
+
+```julia
+canmodify(model, ObjectiveFunction{ScalarAffineFunction{Float64}}(), ScalarConstantChange{Float64})
+```
+"""
+function canmodify end
+canmodify(model::ModelLike, ref, change) = false
+
+"""
+## Constraint Function
+
+    modify!(model::ModelLike, c::ConstraintIndex, change::AbstractFunctionModification)
+
+Apply the modification specified by `change` to the function of constraint `c`.
+
+### Examples
+
+```julia
+modify!(model, c, ScalarConstantChange(10.0))
+```
+
+## Objective Function
+
+modify!(model::ModelLike, ::ObjectiveFunction, change::AbstractFunctionModification)
+
+Apply the modification specified by `change` to the objective function of
+`model`. To change the function completely, call `set!` instead.
+
+### Examples
+
+```julia
+modify!(model, ObjectiveFunction{ScalarAffineFunction{Float64}}(), ScalarConstantChange(10.0))
+```
+"""
+function modify! end