From 077f74a0592f97ac2181ae674b42c519f83aefb7 Mon Sep 17 00:00:00 2001 From: Joaquim Dias Garcia Date: Mon, 1 Jun 2026 00:47:49 +0100 Subject: [PATCH 1/3] Rename ObjectiveValue --- docs/src/usage.md | 6 +++--- src/ConicProgram/ConicProgram.jl | 4 ++-- src/NonLinearProgram/NonLinearProgram.jl | 2 +- src/QuadraticProgram/QuadraticProgram.jl | 4 ++-- src/diff_opt.jl | 10 ++++++---- src/jump_wrapper.jl | 4 ++-- src/moi_wrapper.jl | 2 +- test/jump_wrapper.jl | 6 +++--- test/nlp_program.jl | 24 ++++++++++++------------ test/solver_native_diff.jl | 14 +++++++------- 10 files changed, 39 insertions(+), 37 deletions(-) diff --git a/docs/src/usage.md b/docs/src/usage.md index a851f835e..e9f0d5254 100644 --- a/docs/src/usage.md +++ b/docs/src/usage.md @@ -163,7 +163,7 @@ MOI.set(model, DiffOpt.ForwardConstraintSet(), ParameterRef(p), Parameter(3.0)) MOI.set(model, DiffOpt.ForwardConstraintSet(), ParameterRef(p_c), Parameter(3.0)) DiffOpt.forward_differentiate!(model) -MOI.get(model, DiffOpt.ForwardObjectiveSensitivity()) +MOI.get(model, DiffOpt.ForwardObjectiveValue()) ``` In reverse mode, we can calculate the parameter perturbation with respect to the objective perturbation: @@ -174,7 +174,7 @@ DiffOpt.empty_input_sensitivities!(model) MOI.set( model, - DiffOpt.ReverseObjectiveSensitivity(), + DiffOpt.ReverseObjectiveValue(), 0.1, ) @@ -183,4 +183,4 @@ DiffOpt.reverse_differentiate!(model) MOI.get(model, DiffOpt.ReverseConstraintSet(), ParameterRef(p)) ``` -It is important to note that the (reverse) parameter perturbation given an objective perturbation is somewhat equivalent to the perturbation with respect to solution (since one can be calculated from the other). Therefore, one cannot set both the objective sensitivity (`DiffOpt.ReverseObjectiveSensitivity`) and the solution sensitivity (e.g. `DiffOpt.ReverseVariablePrimal`) at the same time - the code will throw an error if you try to do so. +It is important to note that the (reverse) parameter perturbation given an objective perturbation is somewhat equivalent to the perturbation with respect to solution (since one can be calculated from the other). Therefore, one cannot set both the objective sensitivity (`DiffOpt.ReverseObjectiveValue`) and the solution sensitivity (e.g. `DiffOpt.ReverseVariablePrimal`) at the same time - the code will throw an error if you try to do so. diff --git a/src/ConicProgram/ConicProgram.jl b/src/ConicProgram/ConicProgram.jl index ee5492b07..0159a03f9 100644 --- a/src/ConicProgram/ConicProgram.jl +++ b/src/ConicProgram/ConicProgram.jl @@ -467,9 +467,9 @@ end Method not supported for `DiffOpt.ConicProgram.Model` directly. However, a fallback is provided in `DiffOpt`. """ -function MOI.get(::Model, ::DiffOpt.ForwardObjectiveSensitivity) +function MOI.get(::Model, ::DiffOpt.ForwardObjectiveValue) return throw( - MOI.UnsupportedAttribute(DiffOpt.ForwardObjectiveSensitivity()), + MOI.UnsupportedAttribute(DiffOpt.ForwardObjectiveValue()), ) end diff --git a/src/NonLinearProgram/NonLinearProgram.jl b/src/NonLinearProgram/NonLinearProgram.jl index 9d813b8b1..0de08f301 100644 --- a/src/NonLinearProgram/NonLinearProgram.jl +++ b/src/NonLinearProgram/NonLinearProgram.jl @@ -646,7 +646,7 @@ function MOI.get( return MOI.Parameter{T}(model.back_grad_cache.Δp[ci]) end -function MOI.get(model::Model, ::DiffOpt.ForwardObjectiveSensitivity) +function MOI.get(model::Model, ::DiffOpt.ForwardObjectiveValue) return model.forw_grad_cache.objective_sensitivity_p end diff --git a/src/QuadraticProgram/QuadraticProgram.jl b/src/QuadraticProgram/QuadraticProgram.jl index 8273308e5..173bad088 100644 --- a/src/QuadraticProgram/QuadraticProgram.jl +++ b/src/QuadraticProgram/QuadraticProgram.jl @@ -509,9 +509,9 @@ end Method not supported for `DiffOpt.QuadraticProgram.Model` directly. However, a fallback is provided in `DiffOpt`. """ -function MOI.get(::Model, ::DiffOpt.ForwardObjectiveSensitivity) +function MOI.get(::Model, ::DiffOpt.ForwardObjectiveValue) return throw( - MOI.UnsupportedAttribute(DiffOpt.ForwardObjectiveSensitivity()), + MOI.UnsupportedAttribute(DiffOpt.ForwardObjectiveValue()), ) end diff --git a/src/diff_opt.jl b/src/diff_opt.jl index b61884420..3f3e02a7f 100644 --- a/src/diff_opt.jl +++ b/src/diff_opt.jl @@ -249,19 +249,21 @@ struct ForwardConstraintDual <: MOI.AbstractConstraintAttribute end MOI.is_set_by_optimize(::ForwardConstraintDual) = true """ - ForwardObjectiveSensitivity <: MOI.AbstractModelAttribute + ForwardObjectiveValue <: MOI.AbstractModelAttribute A `MOI.AbstractModelAttribute` to get output objective sensitivity data from forward differentiation. For instance, to get the sensitivity of the objective function with respect to the parameter perturbation, do the following: ```julia -MOI.get(model, DiffOpt.ForwardObjectiveSensitivity()) +MOI.get(model, DiffOpt.ForwardObjectiveValue()) ``` """ -struct ForwardObjectiveSensitivity <: MOI.AbstractModelAttribute end +struct ForwardObjectiveValue <: MOI.AbstractModelAttribute end -MOI.is_set_by_optimize(::ForwardObjectiveSensitivity) = true +MOI.is_set_by_optimize(::ForwardObjectiveValue) = true + +Base.@deprecate_binding ForwardObjectiveSensitivity ForwardObjectiveValue """ ReverseObjectiveFunction <: MOI.AbstractModelAttribute diff --git a/src/jump_wrapper.jl b/src/jump_wrapper.jl index d30c26288..64f43998f 100644 --- a/src/jump_wrapper.jl +++ b/src/jump_wrapper.jl @@ -206,10 +206,10 @@ end Get the value of the objective output sensitivity for forward mode. -Equivalent to `get_attribute(model, DiffOpt.ForwardObjectiveSensitivity())`. +Equivalent to `get_attribute(model, DiffOpt.ForwardObjectiveValue())`. """ function get_forward_objective(model::JuMP.Model) - return MOI.get(model, ForwardObjectiveSensitivity()) + return MOI.get(model, ForwardObjectiveValue()) end """ diff --git a/src/moi_wrapper.jl b/src/moi_wrapper.jl index d46c3f7a6..dd60b8c93 100644 --- a/src/moi_wrapper.jl +++ b/src/moi_wrapper.jl @@ -927,7 +927,7 @@ function MOI.get( ) end -function MOI.get(model::Optimizer, attr::ForwardObjectiveSensitivity) +function MOI.get(model::Optimizer, attr::ForwardObjectiveValue) diff_model = _checked_diff(model, attr, :forward_differentiate!) val = 0.0 try diff --git a/test/jump_wrapper.jl b/test/jump_wrapper.jl index a41f40b1c..7de3686d2 100644 --- a/test/jump_wrapper.jl +++ b/test/jump_wrapper.jl @@ -445,7 +445,7 @@ function test_set_get_attribute() optimize!(model) # Forward via attributes: ForwardParameterValue (set), - # ForwardVariablePrimal (get), ForwardObjectiveSensitivity (get), + # ForwardVariablePrimal (get), ForwardObjectiveValue (get), # ForwardConstraintDual (get). DiffOpt.empty_input_sensitivities!(model) set_attribute(p, DiffOpt.ForwardParameterValue(), 1.0) @@ -456,7 +456,7 @@ function test_set_get_attribute() RTOL @test get_attribute(c1, DiffOpt.ForwardConstraintDual()) ≈ 1.75 atol = ATOL rtol = RTOL - @test get_attribute(model, DiffOpt.ForwardObjectiveSensitivity()) ≈ 2.75 atol = + @test get_attribute(model, DiffOpt.ForwardObjectiveValue()) ≈ 2.75 atol = ATOL rtol = RTOL # Reverse via attributes: ReverseVariablePrimal (set), @@ -546,7 +546,7 @@ function test_attribute_types() @test DiffOpt.ReverseVariablePrimal() isa MOI.AbstractVariableAttribute @test DiffOpt.ForwardObjectiveFunction() isa MOI.AbstractModelAttribute @test DiffOpt.ReverseObjectiveFunction() isa MOI.AbstractModelAttribute - @test DiffOpt.ForwardObjectiveSensitivity() isa MOI.AbstractModelAttribute + @test DiffOpt.ForwardObjectiveValue() isa MOI.AbstractModelAttribute @test DiffOpt.ReverseObjectiveValue() isa MOI.AbstractModelAttribute @test DiffOpt.ForwardConstraintFunction() isa MOI.AbstractConstraintAttribute diff --git a/test/nlp_program.jl b/test/nlp_program.jl index b68180d52..a9ec9e1fa 100644 --- a/test/nlp_program.jl +++ b/test/nlp_program.jl @@ -162,7 +162,7 @@ function test_analytical_simple(; P = 2) # Number of parameters DiffOpt.forward_differentiate!(m) # test Objective Sensitivity wrt parameters - df_dp = MOI.get(m, DiffOpt.ForwardObjectiveSensitivity()) + df_dp = MOI.get(m, DiffOpt.ForwardObjectiveValue()) @test isapprox(df_dp, dot(dual.(con), Δp); atol = 1e-4) @test all(isapprox.(dual.(ParameterRef.(p)), dual.(con); atol = 1e-8)) @@ -642,7 +642,7 @@ end =# ################################################ -function test_ObjectiveSensitivity_model1() +function test_ObjectiveValue_model1() # Model 1 model = Model(() -> DiffOpt.diff_optimizer(Ipopt.Optimizer)) set_silent(model) @@ -669,7 +669,7 @@ function test_ObjectiveSensitivity_model1() DiffOpt.forward_differentiate!(model) # Test Objective Sensitivity wrt parameters - df_dp = MOI.get(model, DiffOpt.ForwardObjectiveSensitivity()) + df_dp = MOI.get(model, DiffOpt.ForwardObjectiveValue()) df = -2cos(p_val) / sin(p_val)^2 @test isapprox(df_dp, df * Δp; atol = 1e-4) @@ -678,7 +678,7 @@ function test_ObjectiveSensitivity_model1() # Test both obj and solution inputs Δf = 0.5 - MOI.set(model, DiffOpt.ReverseObjectiveSensitivity(), Δf) + MOI.set(model, DiffOpt.ReverseObjectiveValue(), Δf) MOI.set(model, DiffOpt.ReverseVariablePrimal(), x, Δp) msg = "Computing reverse differentiation with both solution sensitivities and objective sensitivities. Set `DiffOpt.AllowObjectiveAndSolutionInput()` to `true` to silence this warning." @@ -711,7 +711,7 @@ function test_ObjectiveSensitivity_model1() # Set Reverse Objective Sensitivity Δf = 0.5 - MOI.set(model, DiffOpt.ReverseObjectiveSensitivity(), Δf) + MOI.set(model, DiffOpt.ReverseObjectiveValue(), Δf) # Compute derivatives DiffOpt.reverse_differentiate!(model) @@ -722,7 +722,7 @@ function test_ObjectiveSensitivity_model1() @test isapprox(dp, df * Δf; atol = 1e-4) end -function test_ObjectiveSensitivity_model2() +function test_ObjectiveValue_model2() # Model 2 model = Model(() -> DiffOpt.diff_optimizer(Ipopt.Optimizer)) set_silent(model) @@ -749,7 +749,7 @@ function test_ObjectiveSensitivity_model2() DiffOpt.forward_differentiate!(model) # Test Objective Sensitivity wrt parameters - df_dp = MOI.get(model, DiffOpt.ForwardObjectiveSensitivity()) + df_dp = MOI.get(model, DiffOpt.ForwardObjectiveValue()) @test isapprox(df_dp, -0.3; atol = 1e-4) # Clean up @@ -757,7 +757,7 @@ function test_ObjectiveSensitivity_model2() # Set Reverse Objective Sensitivity Δf = 0.5 - MOI.set(model, DiffOpt.ReverseObjectiveSensitivity(), Δf) + MOI.set(model, DiffOpt.ReverseObjectiveValue(), Δf) # Compute derivatives DiffOpt.reverse_differentiate!(model) @@ -768,7 +768,7 @@ function test_ObjectiveSensitivity_model2() @test isapprox(dp, -1.5; atol = 1e-4) end -function test_ObjectiveSensitivity_direct_param_contrib() +function test_ObjectiveValue_direct_param_contrib() model = DiffOpt.nonlinear_diff_model(Ipopt.Optimizer) set_silent(model) @@ -784,7 +784,7 @@ function test_ObjectiveSensitivity_direct_param_contrib() DiffOpt.set_forward_parameter(model, p, Δp) DiffOpt.forward_differentiate!(model) - df_dp = MOI.get(model, DiffOpt.ForwardObjectiveSensitivity()) + df_dp = MOI.get(model, DiffOpt.ForwardObjectiveValue()) @test isapprox(df_dp, 2 * p_val * Δp, atol = 1e-8) # ≈ 0.6 for p=3 ε = 1e-6 @@ -802,7 +802,7 @@ function test_ObjectiveSensitivity_direct_param_contrib() @test isapprox(df_dp, df_dp_fd, atol = 1e-4) end -function test_ObjectiveSensitivity_subset_parameters() +function test_ObjectiveValue_subset_parameters() # Model with 10 parameters, differentiate only w.r.t. 3rd and 7th model = Model(() -> DiffOpt.diff_optimizer(Ipopt.Optimizer)) set_silent(model) @@ -830,7 +830,7 @@ function test_ObjectiveSensitivity_subset_parameters() DiffOpt.forward_differentiate!(model) # Objective sensitivity should equal sum over selected params only - df_dp = MOI.get(model, DiffOpt.ForwardObjectiveSensitivity()) + df_dp = MOI.get(model, DiffOpt.ForwardObjectiveValue()) @test isapprox(df_dp, 0.007109293; atol = 1e-4) end diff --git a/test/solver_native_diff.jl b/test/solver_native_diff.jl index 87239860e..2c217b02c 100644 --- a/test/solver_native_diff.jl +++ b/test/solver_native_diff.jl @@ -396,7 +396,7 @@ function MOI.set( return end -function MOI.set(s::EqQPSolver, ::DiffOpt.ReverseObjectiveSensitivity, value) +function MOI.set(s::EqQPSolver, ::DiffOpt.ReverseObjectiveValue, value) s.rev_dobj = value return end @@ -516,8 +516,8 @@ function MOI.get(s::EqQPSolver, ::DiffOpt.ForwardConstraintDual, ci::EQ_CI) return s.dnu_fwd[ci.value] end -# ForwardObjectiveSensitivity -function MOI.get(s::EqQPSolver, ::DiffOpt.ForwardObjectiveSensitivity) +# ForwardObjectiveValue +function MOI.get(s::EqQPSolver, ::DiffOpt.ForwardObjectiveValue) return s.fwd_obj_sensitivity end @@ -870,13 +870,13 @@ function test_three_variable_problem() end end -# ── Test reverse with dobj seed (ReverseObjectiveSensitivity) ───────────── +# ── Test reverse with dobj seed (ReverseObjectiveValue) ───────────── function test_reverse_dobj_seed() model, x1, x2, c1 = _setup_model() # Set dobj = 1.0: sensitivity of the objective value w.r.t. problem data - MOI.set(model, DiffOpt.ReverseObjectiveSensitivity(), 1.0) + MOI.set(model, DiffOpt.ReverseObjectiveValue(), 1.0) DiffOpt.reverse_differentiate!(model) # x* = [0, 1], nu* = [-3], Q = I, c = [3, 2] @@ -908,7 +908,7 @@ function test_forward_objective_sensitivity() # dobj/dt = (Qx + c)'dx + dc'x = [3,3]'*dx + [1,0]'*[0,1] expected = dot([3.0, 3.0], fwd[1:2]) + dot([1.0, 0.0], [0.0, 1.0]) - @test MOI.get(model, DiffOpt.ForwardObjectiveSensitivity()) ≈ expected atol = + @test MOI.get(model, DiffOpt.ForwardObjectiveValue()) ≈ expected atol = ATOL end @@ -979,7 +979,7 @@ function test_reverse_dobj_and_dx_seed() model, x1, x2, c1 = _setup_model() MOI.set(model, DiffOpt.AllowObjectiveAndSolutionInput(), true) - MOI.set(model, DiffOpt.ReverseObjectiveSensitivity(), 1.0) + MOI.set(model, DiffOpt.ReverseObjectiveValue(), 1.0) MOI.set(model, DiffOpt.ReverseVariablePrimal(), x1, 1.0) DiffOpt.reverse_differentiate!(model) From 0ed21ebdba0960ae57f99e104b18ce4db34d2c4b Mon Sep 17 00:00:00 2001 From: Joaquim Dias Garcia Date: Mon, 1 Jun 2026 00:57:04 +0100 Subject: [PATCH 2/3] fmt --- src/ConicProgram/ConicProgram.jl | 6 ++---- src/QuadraticProgram/QuadraticProgram.jl | 4 +--- test/nlp_program.jl | 24 ++++++++++++++---------- test/solver_native_diff.jl | 3 +-- 4 files changed, 18 insertions(+), 19 deletions(-) diff --git a/src/ConicProgram/ConicProgram.jl b/src/ConicProgram/ConicProgram.jl index 0159a03f9..5d2388a68 100644 --- a/src/ConicProgram/ConicProgram.jl +++ b/src/ConicProgram/ConicProgram.jl @@ -452,7 +452,7 @@ function DiffOpt._get_dA( g = model.back_grad_cache.g πz = model.back_grad_cache.πz #return DiffOpt.lazy_combination(-, g, πz, n .+ i, 1:n) - return g[n .+ i] * πz[1:n]' - πz[n .+ i] * g[1:n]' + return g[n.+i] * πz[1:n]' - πz[n.+i] * g[1:n]' end function MOI.get( @@ -468,9 +468,7 @@ Method not supported for `DiffOpt.ConicProgram.Model` directly. However, a fallback is provided in `DiffOpt`. """ function MOI.get(::Model, ::DiffOpt.ForwardObjectiveValue) - return throw( - MOI.UnsupportedAttribute(DiffOpt.ForwardObjectiveValue()), - ) + return throw(MOI.UnsupportedAttribute(DiffOpt.ForwardObjectiveValue())) end """ diff --git a/src/QuadraticProgram/QuadraticProgram.jl b/src/QuadraticProgram/QuadraticProgram.jl index 173bad088..1c5464604 100644 --- a/src/QuadraticProgram/QuadraticProgram.jl +++ b/src/QuadraticProgram/QuadraticProgram.jl @@ -510,9 +510,7 @@ Method not supported for `DiffOpt.QuadraticProgram.Model` directly. However, a fallback is provided in `DiffOpt`. """ function MOI.get(::Model, ::DiffOpt.ForwardObjectiveValue) - return throw( - MOI.UnsupportedAttribute(DiffOpt.ForwardObjectiveValue()), - ) + return throw(MOI.UnsupportedAttribute(DiffOpt.ForwardObjectiveValue())) end """ diff --git a/test/nlp_program.jl b/test/nlp_program.jl index a9ec9e1fa..724b7caa6 100644 --- a/test/nlp_program.jl +++ b/test/nlp_program.jl @@ -76,10 +76,11 @@ function test_compute_optimal_hess_jacobian() optimize!(model) @assert is_solved_and_feasible(model) # Create evaluator - nlp_model = DiffOpt._diff( - model.moi_backend.optimizer.model, - DiffOpt.ForwardDifferentiate(), - ).model + nlp_model = + DiffOpt._diff( + model.moi_backend.optimizer.model, + DiffOpt.ForwardDifferentiate(), + ).model _test_create_evaluator(nlp_model) cons = nlp_model.cache.cons y = [ @@ -412,9 +413,9 @@ function test_compute_derivatives_Analytical(; DICT_PROBLEMS = DICT_PROBLEMS_Analytical_no_cc, ) @testset "Compute Derivatives Analytical: $problem_name" for ( - problem_name, - (p_a, Δp, Δx, Δy, Δvu, Δvl, model_generator), - ) in DICT_PROBLEMS + problem_name, + (p_a, Δp, Δx, Δy, Δvu, Δvl, model_generator), + ) in DICT_PROBLEMS # OPT Problem model, primal_vars, cons, params = model_generator() set_parameter_value.(params, p_a) @@ -814,7 +815,7 @@ function test_ObjectiveValue_subset_parameters() @variable(model, x[1:10]) # Constraints (decouple by index; gives us per-parameter duals) - @constraint(model, c[i=1:10], x[i] * sin(p[i]) == 1) + @constraint(model, c[i = 1:10], x[i] * sin(p[i]) == 1) @objective(model, Min, sum(x)) optimize!(model) @@ -930,8 +931,11 @@ function test_ReverseConstraintDual() @test all( isapprox( [ - MOI.get(m, DiffOpt.ReverseConstraintSet(), ParameterRef(p[i])).value - for i in 1:2 + MOI.get( + m, + DiffOpt.ReverseConstraintSet(), + ParameterRef(p[i]), + ).value for i in 1:2 ], zeros(2); atol = 1e-8, diff --git a/test/solver_native_diff.jl b/test/solver_native_diff.jl index 2c217b02c..54716121f 100644 --- a/test/solver_native_diff.jl +++ b/test/solver_native_diff.jl @@ -908,8 +908,7 @@ function test_forward_objective_sensitivity() # dobj/dt = (Qx + c)'dx + dc'x = [3,3]'*dx + [1,0]'*[0,1] expected = dot([3.0, 3.0], fwd[1:2]) + dot([1.0, 0.0], [0.0, 1.0]) - @test MOI.get(model, DiffOpt.ForwardObjectiveValue()) ≈ expected atol = - ATOL + @test MOI.get(model, DiffOpt.ForwardObjectiveValue()) ≈ expected atol = ATOL end # ── Test forward twice (re-differentiation in forward mode) ────────────── From c3299632f637b193d75112c8443530d57194ce9c Mon Sep 17 00:00:00 2001 From: Joaquim Dias Garcia Date: Mon, 1 Jun 2026 01:10:55 +0100 Subject: [PATCH 3/3] fmt --- src/ConicProgram/ConicProgram.jl | 2 +- test/nlp_program.jl | 24 ++++++++++-------------- 2 files changed, 11 insertions(+), 15 deletions(-) diff --git a/src/ConicProgram/ConicProgram.jl b/src/ConicProgram/ConicProgram.jl index 5d2388a68..154ffdc8d 100644 --- a/src/ConicProgram/ConicProgram.jl +++ b/src/ConicProgram/ConicProgram.jl @@ -452,7 +452,7 @@ function DiffOpt._get_dA( g = model.back_grad_cache.g πz = model.back_grad_cache.πz #return DiffOpt.lazy_combination(-, g, πz, n .+ i, 1:n) - return g[n.+i] * πz[1:n]' - πz[n.+i] * g[1:n]' + return g[n .+ i] * πz[1:n]' - πz[n .+ i] * g[1:n]' end function MOI.get( diff --git a/test/nlp_program.jl b/test/nlp_program.jl index 724b7caa6..a9ec9e1fa 100644 --- a/test/nlp_program.jl +++ b/test/nlp_program.jl @@ -76,11 +76,10 @@ function test_compute_optimal_hess_jacobian() optimize!(model) @assert is_solved_and_feasible(model) # Create evaluator - nlp_model = - DiffOpt._diff( - model.moi_backend.optimizer.model, - DiffOpt.ForwardDifferentiate(), - ).model + nlp_model = DiffOpt._diff( + model.moi_backend.optimizer.model, + DiffOpt.ForwardDifferentiate(), + ).model _test_create_evaluator(nlp_model) cons = nlp_model.cache.cons y = [ @@ -413,9 +412,9 @@ function test_compute_derivatives_Analytical(; DICT_PROBLEMS = DICT_PROBLEMS_Analytical_no_cc, ) @testset "Compute Derivatives Analytical: $problem_name" for ( - problem_name, - (p_a, Δp, Δx, Δy, Δvu, Δvl, model_generator), - ) in DICT_PROBLEMS + problem_name, + (p_a, Δp, Δx, Δy, Δvu, Δvl, model_generator), + ) in DICT_PROBLEMS # OPT Problem model, primal_vars, cons, params = model_generator() set_parameter_value.(params, p_a) @@ -815,7 +814,7 @@ function test_ObjectiveValue_subset_parameters() @variable(model, x[1:10]) # Constraints (decouple by index; gives us per-parameter duals) - @constraint(model, c[i = 1:10], x[i] * sin(p[i]) == 1) + @constraint(model, c[i=1:10], x[i] * sin(p[i]) == 1) @objective(model, Min, sum(x)) optimize!(model) @@ -931,11 +930,8 @@ function test_ReverseConstraintDual() @test all( isapprox( [ - MOI.get( - m, - DiffOpt.ReverseConstraintSet(), - ParameterRef(p[i]), - ).value for i in 1:2 + MOI.get(m, DiffOpt.ReverseConstraintSet(), ParameterRef(p[i])).value + for i in 1:2 ], zeros(2); atol = 1e-8,