Add hability to query duals of multiplicative parameters in parameter… (#171)

* Add hability to query duals of multiplicative parameters in parameter * parameter terms

* fix condition to evaluate duals of parameter * parameter

* fix formatting

* update delete methods

* Add a new deletion test

* [no ci] remove README

* [no ci] Remove revise folder

* update implementation

* Add missing term in quadratic parametric function

* Fix formatting

* Update test/jump_tests.jl

* fix corner case fo quadratic parameter

* remove unnecessary types

---------

Co-authored-by: Joaquim <[email protected]>
Co-authored-by: joaquimg <[email protected]>

Author: guilhermebodin

Project.toml

@@ -1,7 +1,7 @@
 name = "ParametricOptInterface"
 uuid = "0ce4ce61-57bf-432b-a095-efac525d185e"
 authors = ["Tomás Gutierrez <[email protected]>"]
-version = "0.9.0"
+version = "0.10.0"
 
 [deps]
 MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee"

src/MOI_wrapper.jl

@@ -56,12 +56,11 @@ function _cache_multiplicative_params!(
     f::ParametricQuadraticFunction{T},
 ) where {T}
     for term in f.pv
-        push!(model.multiplicative_parameters, term.variable_1.value)
+        push!(model.multiplicative_parameters_pv, term.variable_1.value)
     end
-    # TODO compute these duals might be feasible
     for term in f.pp
-        push!(model.multiplicative_parameters, term.variable_1.value)
-        push!(model.multiplicative_parameters, term.variable_2.value)
+        push!(model.multiplicative_parameters_pp, term.variable_1.value)
+        push!(model.multiplicative_parameters_pp, term.variable_2.value)
     end
     return
 end
@@ -97,7 +96,8 @@ function MOI.is_empty(model::Optimizer)
            #
            isempty(model.vector_affine_constraint_cache) &&
            #
-           isempty(model.multiplicative_parameters) &&
+           isempty(model.multiplicative_parameters_pv) &&
+           isempty(model.multiplicative_parameters_pp) &&
            isempty(model.dual_value_of_parameters) &&
            model.number_of_parameters_in_model == 0 &&
            isempty(model.ext)
@@ -130,7 +130,8 @@ function MOI.empty!(model::Optimizer{T}) where {T}
     #
     empty!(model.vector_affine_constraint_cache)
     #
-    empty!(model.multiplicative_parameters)
+    empty!(model.multiplicative_parameters_pv)
+    empty!(model.multiplicative_parameters_pp)
     empty!(model.dual_value_of_parameters)
     #
     model.number_of_parameters_in_model = 0
@@ -827,14 +828,14 @@ function MOI.delete(
 ) where {F<:MOI.ScalarQuadraticFunction,S<:MOI.AbstractSet}
     if haskey(model.quadratic_outer_to_inner, c)
         ci_inner = model.quadratic_outer_to_inner[c]
-        deleteat!(model.quadratic_outer_to_inner, c)
-        deleteat!(model.quadratic_constraint_cache, c)
-        deleteat!(model.quadratic_constraint_cache_set, c)
+        delete!(model.quadratic_outer_to_inner, c)
+        delete!(model.quadratic_constraint_cache, c)
+        delete!(model.quadratic_constraint_cache_set, c)
         MOI.delete(model.optimizer, ci_inner)
     else
         MOI.delete(model.optimizer, c)
     end
-    deleteat!(model.constraint_outer_to_inner, c)
+    delete!(model.constraint_outer_to_inner, c)
     return
 end
 
@@ -870,7 +871,7 @@ function MOI.delete(
 ) where {F<:MOI.VectorAffineFunction,S<:MOI.AbstractSet}
     MOI.delete(model.optimizer, c)
     delete!(model.constraint_outer_to_inner, c)
-    deleteat!(model.vector_affine_constraint_cache, c)
+    delete!(model.vector_affine_constraint_cache, c)
     return
 end
 

src/ParametricOptInterface.jl

@@ -158,7 +158,8 @@ mutable struct Optimizer{T,OT<:MOI.ModelLike} <: MOI.AbstractOptimizer
     }
 
     #
-    multiplicative_parameters::Set{Int64}
+    multiplicative_parameters_pv::Set{Int64}
+    multiplicative_parameters_pp::Set{Int64}
     dual_value_of_parameters::Vector{T}
 
     # params
@@ -221,6 +222,7 @@ mutable struct Optimizer{T,OT<:MOI.ModelLike} <: MOI.AbstractOptimizer
             DoubleDict{ParametricVectorAffineFunction{T}}(),
             # other
             Set{Int64}(),
+            Set{Int64}(),
             Vector{T}(),
             evaluate_duals,
             0,

src/duals.jl

@@ -48,9 +48,9 @@ function _update_duals_from_quadratic_constraints!(model::Optimizer)
 end
 
 function _compute_parameters_in_ci!(
-    model::OT,
+    model::Optimizer,
     constraint_cache_inner::DoubleDictInner{F,S,V},
-) where {OT,F,S,V}
+) where {F,S,V}
     for (inner_ci, pf) in constraint_cache_inner
         _compute_parameters_in_ci!(model, pf, inner_ci)
     end
@@ -59,9 +59,9 @@ end
 
 function _compute_parameters_in_ci!(
     model::Optimizer{T},
-    pf,
+    pf::ParametricAffineFunction{T},
     ci::MOI.ConstraintIndex{F,S},
-) where {F,S} where {T}
+) where {F,S,T}
     cons_dual = MOI.get(model.optimizer, MOI.ConstraintDual(), ci)
     for term in pf.p
         model.dual_value_of_parameters[p_val(term.variable)] -=
@@ -70,6 +70,32 @@ function _compute_parameters_in_ci!(
     return
 end
 
+function _compute_parameters_in_ci!(
+    model::Optimizer{T},
+    pf::ParametricQuadraticFunction{T},
+    ci::MOI.ConstraintIndex{F,S},
+) where {F,S,T}
+    cons_dual = MOI.get(model.optimizer, MOI.ConstraintDual(), ci)
+    for term in pf.p
+        model.dual_value_of_parameters[p_val(term.variable)] -=
+            cons_dual * term.coefficient
+    end
+    for term in pf.pp
+        coef = ifelse(term.variable_1 == term.variable_2, T(1 // 2), T(1))
+        model.dual_value_of_parameters[p_val(term.variable_1)] -=
+            coef *
+            cons_dual *
+            term.coefficient *
+            MOI.get(model, ParameterValue(), term.variable_2)
+        model.dual_value_of_parameters[p_val(term.variable_2)] -=
+            coef *
+            cons_dual *
+            term.coefficient *
+            MOI.get(model, ParameterValue(), term.variable_1)
+    end
+    return
+end
+
 function _compute_parameters_in_ci!(
     model::Optimizer{T},
     pf::ParametricVectorAffineFunction{T},
@@ -143,7 +169,7 @@ function MOI.get(
 end
 
 function _is_additive(model::Optimizer, cp::MOI.ConstraintIndex)
-    if cp.value in model.multiplicative_parameters
+    if cp.value in model.multiplicative_parameters_pv
         return false
     end
     return true

test/jump_tests.jl

@@ -1089,3 +1089,43 @@ function test_get_quadratic_constraint()
     @test value(c) ≈ 2.0 * value(x)
     return
 end
+
+function test_get_duals_from_multiplicative_parameters_1()
+    model = Model(() -> POI.Optimizer(GLPK.Optimizer()))
+    @variable(model, x)
+    @variable(model, p1 in Parameter(2.0))
+    @variable(model, p2 in Parameter(2.0))
+    @constraint(model, c, 3 * x >= p1 * p2)
+    @objective(model, Min, sum(x))
+    optimize!(model)
+    @test dual(c) ≈ 1.0 / 3.0
+    @test MOI.get.(model, POI.ParameterDual(), p1) ≈ 2.0 / 3
+    @test MOI.get.(model, POI.ParameterDual(), p2) ≈ 2.0 / 3
+    return
+end
+
+function test_get_duals_from_multiplicative_parameters_2()
+    model = Model(() -> POI.Optimizer(GLPK.Optimizer()))
+    @variable(model, x)
+    @variable(model, p1 in Parameter(40.0))
+    @variable(model, p2 in Parameter(2.0))
+    @constraint(model, c, 3 * x >= p1 * p2)
+    @objective(model, Min, sum(x))
+    optimize!(model)
+    @test dual(c) ≈ 1.0 / 3.0
+    @test MOI.get.(model, POI.ParameterDual(), p1) ≈ 2.0 / 3
+    @test MOI.get.(model, POI.ParameterDual(), p2) ≈ 40.0 / 3
+    return
+end
+
+function test_get_duals_from_multiplicative_parameters_3()
+    model = Model(() -> POI.Optimizer(GLPK.Optimizer()))
+    @variable(model, x)
+    @variable(model, p in Parameter(4.0))
+    @constraint(model, c, 3 * x >= p * p)
+    @objective(model, Min, sum(x))
+    optimize!(model)
+    @test dual(c) ≈ 1.0 / 3.0
+    @test MOI.get.(model, POI.ParameterDual(), p) ≈ 2 * 4.0 / 3
+    return
+end

test/moi_tests.jl

@@ -150,6 +150,7 @@ function test_basic_special_cases_of_getters()
     @test MOI.get(optimizer, MOI.ObjectiveFunctionType()) ==
           MOI.ScalarQuadraticFunction{Float64}
     @test MOI.get(optimizer, MOI.NumberOfVariables()) == 3
+    MOI.delete(optimizer, cons_index)
     return
 end
 
@@ -1383,10 +1384,8 @@ function test_qp_objective_parameter_times_parameter()
         0.0,
         atol = ATOL,
     )
-    err =
-        ErrorException("Cannot compute the dual of a multiplicative parameter")
-    @test_throws err MOI.get(optimizer, MOI.ConstraintDual(), cy)
-    @test_throws err MOI.get(optimizer, MOI.ConstraintDual(), cz)
+    @test MOI.get(optimizer, MOI.ConstraintDual(), cy) == 0.0
+    @test MOI.get(optimizer, MOI.ConstraintDual(), cz) == 0.0
     MOI.set(optimizer, MOI.ConstraintSet(), cy, MOI.Parameter(2.0))
     MOI.optimize!(optimizer)
     @test isapprox(MOI.get(optimizer, MOI.ObjectiveValue()), 2.0, atol = ATOL)