add possible fix to scalarize bridge error

Author: joaquimg

src/bridges.jl

@@ -43,6 +43,27 @@ function MOI.get(
         MOI.get(model, attr, bridge.vector_constraint),
     )[1]
 end
+
+function MOI.set(
+    model::MOI.ModelLike,
+    attr::ForwardConstraintFunction,
+    bridge::MOI.Bridges.Constraint.ScalarizeBridge{T},
+    value,
+) where {T}
+    MOI.set.(model, attr, bridge.scalar_constraints, value)
+    return
+end
+
+function MOI.get(
+    model::MOI.ModelLike,
+    attr::ReverseConstraintFunction,
+    bridge::MOI.Bridges.Constraint.ScalarizeBridge,
+)
+    return _vectorize(
+        MOI.get.(model, attr, bridge.scalar_constraints),
+    )
+end
+
 function MOI.get(
     model::MOI.ModelLike,
     attr::DiffOpt.ReverseConstraintFunction,

src/utils.jl

@@ -3,6 +3,8 @@
 # Use of this source code is governed by an MIT-style license that can be found
 # in the LICENSE.md file or at https://opensource.org/licenses/MIT.
 
+# Helpers for objective function
+
 # Representation of MOI functions using SparseArrays
 # Might be able to replace in the future by a function in MOI, see
 # https://github.com/jump-dev/MathOptInterface.jl/pull/1238
@@ -152,6 +154,8 @@ function sparse_array_representation(
     )
 end
 
+# Helpers for scalar constraints
+
 # In the future, we could replace by https://github.com/jump-dev/MathOptInterface.jl/pull/1238
 """
     VectorScalarAffineFunction{T, VT} <: MOI.AbstractScalarFunction
@@ -228,6 +232,8 @@ function JuMP.coefficient(
     return JuMP.coefficient(func.affine, vi)
 end
 
+# Helpers for Vector constraints
+
 """
     MatrixVectorAffineFunction{T, VT} <: MOI.AbstractVectorFunction
 
@@ -260,6 +266,17 @@ function standard_form(func::MatrixVectorAffineFunction{T}) where {T}
     return convert(MOI.VectorAffineFunction{T}, func)
 end
 
+_get_terms(f::VectorScalarAffineFunction) = f.terms
+_get_constant(f::VectorScalarAffineFunction) = f.constant
+function _vectorize(vec::Vector{T}) where {T<:VectorScalarAffineFunction}
+    terms = LazyArrays.@~ LazyArrays.ApplyArray(hcat, _get_terms.(vec)...)'
+    constants = LazyArrays.ApplyArray(vcat, _get_constant.(vec)...)
+    AT = typeof(terms)
+    VT = typeof(constants)
+    ret = MatrixVectorAffineFunction{AT,VT}(terms, constants)
+    return ret
+end
+
 # Only used for testing at the moment so performance is not critical so
 # converting to standard form is ok
 function MOIU.isapprox_zero(

test/parameters.jl

@@ -646,6 +646,30 @@ function test_diff_errors()
     return
 end
 
+function test_scalarize_bridge()
+    using JuMP, DiffOpt, HiGHS
+
+    b = [1.0, 2.0]
+
+    m = Model(
+        () -> DiffOpt.diff_optimizer(
+            HiGHS.Optimizer;
+            with_parametric_opt_interface = true,
+        ),
+    )
+    @variable(m, x[1:2] >= 0)
+    @variable(m, c[1:2] in MOI.Parameter.(b))
+    @constraint(m, con, x <= c)
+    @objective(m, Max, sum(x))
+    optimize!(m)
+
+    MOI.set(m, DiffOpt.ReverseVariablePrimal(), m[:x][1], 1.0)
+    DiffOpt.reverse_differentiate!(m)
+    @test MOI.get.(m, DiffOpt.ReverseConstraintSet(), ParameterRef.(c)) == [1, 0]
+
+    return
+end
+
 end # module
 
 TestParameters.runtests()