From c736212ff23d472ba5963b316d37dfa77939b684 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Beno=C3=AEt=20Legat?= Date: Thu, 13 Aug 2026 08:23:46 +0000 Subject: [PATCH 1/5] Use MOI.Nonlinear.QPBlockData Delete the local QPBlockData (utils.jl) in favor of the copy that moved to MathOptInterface. Two adaptations: - MOI's QPBlockData treats a variable as a parameter if and only if its index is a key of the parameters dictionary, instead of the index-offset convention, so parameters are registered when the constrained variable is added (the value is still re-synced in copy_parameters before every solve). - eval_constraint_jacobian and eval_hessian_lagrangian now return the number of entries written instead of a one-indexed cursor, so the callers drop the offset adjustment. --- ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl | 15 +- ext/IpoptMathOptInterfaceExt/utils.jl | 541 -------------------- 2 files changed, 11 insertions(+), 545 deletions(-) delete mode 100644 ext/IpoptMathOptInterfaceExt/utils.jl diff --git a/ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl b/ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl index 5450675..cea2213 100644 --- a/ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl +++ b/ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl @@ -3,7 +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. -include("utils.jl") +const QPBlockData = MOI.Nonlinear.QPBlockData + const _PARAMETER_OFFSET = 0x00f0000000000000 @@ -193,6 +194,11 @@ function MOI.add_constrained_variable( push!(model.list_of_variable_indices, p) model.parameters[p] = MOI.Nonlinear.add_parameter(model.nlp_model, set.value) + # `QPBlockData` treats a variable as a parameter if and only if its index + # is a key of `parameters`, so the parameter must be registered before + # any structure query. The value is re-synced in `copy_parameters` before + # every solve. + model.qp_data.parameters[p.value] = set.value ci = MOI.ConstraintIndex{MOI.VariableIndex,typeof(set)}(p.value) return p, ci end @@ -1182,7 +1188,6 @@ end function MOI.eval_constraint_jacobian(model::Optimizer, values, x) offset = MOI.eval_constraint_jacobian(model.qp_data, values, x) - offset -= 1 # .qp_data returns one-indexed offset for (f, s) in model.vector_nonlinear_oracle_constraints offset = _eval_constraint_jacobian(values, offset, x, f, s) end @@ -1235,7 +1240,6 @@ end function MOI.eval_hessian_lagrangian(model::Optimizer, H, x, σ, μ) offset = MOI.eval_hessian_lagrangian(model.qp_data, H, x, σ, μ) - offset -= 1 # .qp_data returns one-indexed offset μ_offset = length(model.qp_data) for (f, s) in model.vector_nonlinear_oracle_constraints offset, μ_offset = @@ -1377,7 +1381,10 @@ function _setup_model(model::Optimizer) ) end has_quadratic_constraints = - any(isequal(_kFunctionTypeScalarQuadratic), model.qp_data.function_type) + any( + isequal(MOI.Nonlinear._kFunctionTypeScalarQuadratic), + model.qp_data.function_type, + ) has_nlp_constraints = !isempty(model.nlp_data.constraint_bounds) || !isempty(model.vector_nonlinear_oracle_constraints) diff --git a/ext/IpoptMathOptInterfaceExt/utils.jl b/ext/IpoptMathOptInterfaceExt/utils.jl deleted file mode 100644 index cedaed5..0000000 --- a/ext/IpoptMathOptInterfaceExt/utils.jl +++ /dev/null @@ -1,541 +0,0 @@ -# Copyright (c) 2013: Iain Dunning, Miles Lubin, and contributors -# -# 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. - -# !!! warning -# -# The contents of this file are experimental. -# -# Until this message is removed, breaking changes to the functions and -# types, including their deletion, may be introduced in any minor or patch -# release of Ipopt. - -@enum( - _FunctionType, - _kFunctionTypeVariableIndex, - _kFunctionTypeScalarAffine, - _kFunctionTypeScalarQuadratic, -) - -function _function_type_to_func(::Type{T}, k::_FunctionType) where {T} - if k == _kFunctionTypeVariableIndex - return MOI.VariableIndex - elseif k == _kFunctionTypeScalarAffine - return MOI.ScalarAffineFunction{T} - else - @assert k == _kFunctionTypeScalarQuadratic - return MOI.ScalarQuadraticFunction{T} - end -end - -_function_info(::MOI.VariableIndex) = _kFunctionTypeVariableIndex -_function_info(::MOI.ScalarAffineFunction) = _kFunctionTypeScalarAffine -_function_info(::MOI.ScalarQuadraticFunction) = _kFunctionTypeScalarQuadratic - -@enum( - _BoundType, - _kBoundTypeLessThan, - _kBoundTypeGreaterThan, - _kBoundTypeEqualTo, - _kBoundTypeInterval, -) - -_set_info(s::MOI.LessThan) = _kBoundTypeLessThan, -Inf, s.upper -_set_info(s::MOI.GreaterThan) = _kBoundTypeGreaterThan, s.lower, Inf -_set_info(s::MOI.EqualTo) = _kBoundTypeEqualTo, s.value, s.value -_set_info(s::MOI.Interval) = _kBoundTypeInterval, s.lower, s.upper - -function _bound_type_to_set(::Type{T}, k::_BoundType) where {T} - if k == _kBoundTypeEqualTo - return MOI.EqualTo{T} - elseif k == _kBoundTypeLessThan - return MOI.LessThan{T} - elseif k == _kBoundTypeGreaterThan - return MOI.GreaterThan{T} - else - @assert k == _kBoundTypeInterval - return MOI.Interval{T} - end -end - -mutable struct QPBlockData{T} - objective::Union{MOI.ScalarAffineFunction{T},MOI.ScalarQuadraticFunction{T}} - objective_function_type::_FunctionType - constraints::Vector{ - Union{MOI.ScalarAffineFunction{T},MOI.ScalarQuadraticFunction{T}}, - } - g_L::Vector{T} - g_U::Vector{T} - mult_g::Vector{Union{Nothing,T}} - function_type::Vector{_FunctionType} - bound_type::Vector{_BoundType} - parameters::Dict{Int64,T} - - function QPBlockData{T}() where {T} - return new( - zero(MOI.ScalarQuadraticFunction{T}), - _kFunctionTypeScalarAffine, - Union{MOI.ScalarAffineFunction{T},MOI.ScalarQuadraticFunction{T}}[], - T[], - T[], - Union{Nothing,T}[], - _FunctionType[], - _BoundType[], - Dict{Int64,T}(), - ) - end -end - -function _value(variable::MOI.VariableIndex, x::Vector, p::Dict) - if _is_parameter(variable) - return p[variable.value] - else - return x[variable.value] - end -end - -function eval_function( - f::MOI.ScalarQuadraticFunction{T}, - x::Vector{T}, - p::Dict{Int64,T}, -)::T where {T} - y = f.constant - for term in f.affine_terms - y += term.coefficient * _value(term.variable, x, p) - end - for term in f.quadratic_terms - v1 = _value(term.variable_1, x, p) - v2 = _value(term.variable_2, x, p) - if term.variable_1 == term.variable_2 - y += term.coefficient * v1 * v2 / 2 - else - y += term.coefficient * v1 * v2 - end - end - return y -end - -function eval_function( - f::MOI.ScalarAffineFunction{T}, - x::Vector{T}, - p::Dict{Int64,T}, -)::T where {T} - y = f.constant - for term in f.terms - y += term.coefficient * _value(term.variable, x, p) - end - return y -end - -function eval_dense_gradient( - ∇f::Vector{T}, - f::MOI.ScalarQuadraticFunction{T}, - x::Vector{T}, - p::Dict{Int64,T}, -)::Nothing where {T} - for term in f.affine_terms - if !_is_parameter(term.variable) - ∇f[term.variable.value] += term.coefficient - end - end - for term in f.quadratic_terms - if !_is_parameter(term.variable_1) - v = _value(term.variable_2, x, p) - ∇f[term.variable_1.value] += term.coefficient * v - end - if term.variable_1 != term.variable_2 && !_is_parameter(term.variable_2) - v = _value(term.variable_1, x, p) - ∇f[term.variable_2.value] += term.coefficient * v - end - end - return -end - -function eval_dense_gradient( - ∇f::Vector{T}, - f::MOI.ScalarAffineFunction{T}, - x::Vector{T}, - p::Dict{Int64,T}, -)::Nothing where {T} - for term in f.terms - if !_is_parameter(term.variable) - ∇f[term.variable.value] += term.coefficient - end - end - return -end - -function append_sparse_gradient_structure!( - f::MOI.ScalarQuadraticFunction, - J, - row, -) - for term in f.affine_terms - if !_is_parameter(term.variable) - push!(J, (row, term.variable.value)) - end - end - for term in f.quadratic_terms - if !_is_parameter(term.variable_1) - push!(J, (row, term.variable_1.value)) - end - if term.variable_1 != term.variable_2 && !_is_parameter(term.variable_2) - push!(J, (row, term.variable_2.value)) - end - end - return -end - -function append_sparse_gradient_structure!(f::MOI.ScalarAffineFunction, J, row) - for term in f.terms - if !_is_parameter(term.variable) - push!(J, (row, term.variable.value)) - end - end - return -end - -function eval_sparse_gradient( - ∇f::AbstractVector{T}, - f::MOI.ScalarQuadraticFunction{T}, - x::Vector{T}, - p::Dict{Int64,T}, -)::Int where {T} - i = 0 - for term in f.affine_terms - if !_is_parameter(term.variable) - i += 1 - ∇f[i] = term.coefficient - end - end - for term in f.quadratic_terms - if !_is_parameter(term.variable_1) - v = _value(term.variable_2, x, p) - i += 1 - ∇f[i] = term.coefficient * v - end - if term.variable_1 != term.variable_2 && !_is_parameter(term.variable_2) - v = _value(term.variable_1, x, p) - i += 1 - ∇f[i] = term.coefficient * v - end - end - return i -end - -function eval_sparse_gradient( - ∇f::AbstractVector{T}, - f::MOI.ScalarAffineFunction{T}, - x::Vector{T}, - p::Dict{Int64,T}, -)::Int where {T} - i = 0 - for term in f.terms - if !_is_parameter(term.variable) - i += 1 - ∇f[i] = term.coefficient - end - end - return i -end - -function append_sparse_hessian_structure!(f::MOI.ScalarQuadraticFunction, H) - for term in f.quadratic_terms - if _is_parameter(term.variable_1) || _is_parameter(term.variable_2) - continue - end - push!(H, (term.variable_1.value, term.variable_2.value)) - end - return -end - -append_sparse_hessian_structure!(::MOI.ScalarAffineFunction, H) = nothing - -function eval_sparse_hessian( - ∇²f::AbstractVector{T}, - f::MOI.ScalarQuadraticFunction{T}, - σ::T, -)::Int where {T} - i = 0 - for term in f.quadratic_terms - if _is_parameter(term.variable_1) || _is_parameter(term.variable_2) - continue - end - i += 1 - ∇²f[i] = term.coefficient * σ - end - return i -end - -function eval_sparse_hessian( - ∇²f::AbstractVector{T}, - f::MOI.ScalarAffineFunction{T}, - σ::T, -)::Int where {T} - return 0 -end - -Base.length(block::QPBlockData) = length(block.bound_type) - -function MOI.set( - block::QPBlockData{T}, - ::MOI.ObjectiveFunction{F}, - f::F, -) where {T,F<:Union{MOI.VariableIndex,MOI.ScalarAffineFunction{T}}} - block.objective = convert(MOI.ScalarAffineFunction{T}, f) - block.objective_function_type = _function_info(f) - return -end - -function MOI.set( - block::QPBlockData{T}, - ::MOI.ObjectiveFunction{MOI.ScalarQuadraticFunction{T}}, - f::MOI.ScalarQuadraticFunction{T}, -) where {T} - block.objective = f - block.objective_function_type = _function_info(f) - return -end - -function MOI.get(block::QPBlockData{T}, ::MOI.ObjectiveFunctionType) where {T} - return _function_type_to_func(T, block.objective_function_type) -end - -function MOI.get(block::QPBlockData{T}, ::MOI.ObjectiveFunction{F}) where {T,F} - return convert(F, block.objective) -end - -function MOI.get( - block::QPBlockData{T}, - ::MOI.ListOfConstraintTypesPresent, -) where {T} - constraints = Set{Tuple{Type,Type}}() - for i in 1:length(block) - F = _function_type_to_func(T, block.function_type[i]) - S = _bound_type_to_set(T, block.bound_type[i]) - push!(constraints, (F, S)) - end - return collect(constraints) -end - -function MOI.is_valid( - block::QPBlockData{T}, - ci::MOI.ConstraintIndex{F,S}, -) where { - T, - F<:Union{MOI.ScalarAffineFunction{T},MOI.ScalarQuadraticFunction{T}}, - S<:Union{MOI.LessThan{T},MOI.GreaterThan{T},MOI.EqualTo{T},MOI.Interval{T}}, -} - return 1 <= ci.value <= length(block) -end - -function MOI.get( - block::QPBlockData{T}, - ::MOI.ListOfConstraintIndices{F,S}, -) where { - T, - F<:Union{MOI.ScalarAffineFunction{T},MOI.ScalarQuadraticFunction{T}}, - S<:Union{MOI.LessThan{T},MOI.GreaterThan{T},MOI.EqualTo{T},MOI.Interval{T}}, -} - ret = MOI.ConstraintIndex{F,S}[] - for i in 1:length(block) - if _bound_type_to_set(T, block.bound_type[i]) != S - continue - elseif _function_type_to_func(T, block.function_type[i]) != F - continue - end - push!(ret, MOI.ConstraintIndex{F,S}(i)) - end - return ret -end - -function MOI.get( - block::QPBlockData{T}, - ::MOI.NumberOfConstraints{F,S}, -) where { - T, - F<:Union{MOI.ScalarAffineFunction{T},MOI.ScalarQuadraticFunction{T}}, - S<:Union{MOI.LessThan{T},MOI.GreaterThan{T},MOI.EqualTo{T},MOI.Interval{T}}, -} - return length(MOI.get(block, MOI.ListOfConstraintIndices{F,S}())) -end - -function MOI.add_constraint( - block::QPBlockData{T}, - f::Union{MOI.ScalarAffineFunction{T},MOI.ScalarQuadraticFunction{T}}, - s::Union{MOI.LessThan{T},MOI.GreaterThan{T},MOI.EqualTo{T},MOI.Interval{T}}, -) where {T} - push!(block.constraints, f) - bound_type, l, u = _set_info(s) - push!(block.g_L, l) - push!(block.g_U, u) - push!(block.mult_g, nothing) - push!(block.bound_type, bound_type) - push!(block.function_type, _function_info(f)) - return MOI.ConstraintIndex{typeof(f),typeof(s)}(length(block.bound_type)) -end - -function MOI.get( - block::QPBlockData{T}, - ::MOI.ConstraintFunction, - c::MOI.ConstraintIndex{F,S}, -) where {T,F,S} - return convert(F, block.constraints[c.value]) -end - -function MOI.get( - block::QPBlockData{T}, - ::MOI.ConstraintSet, - c::MOI.ConstraintIndex{F,S}, -) where {T,F,S} - row = c.value - if block.bound_type[row] == _kBoundTypeEqualTo - return MOI.EqualTo(block.g_L[row]) - elseif block.bound_type[row] == _kBoundTypeLessThan - return MOI.LessThan(block.g_U[row]) - elseif block.bound_type[row] == _kBoundTypeGreaterThan - return MOI.GreaterThan(block.g_L[row]) - else - @assert block.bound_type[row] == _kBoundTypeInterval - return MOI.Interval(block.g_L[row], block.g_U[row]) - end -end - -function MOI.set( - block::QPBlockData{T}, - ::MOI.ConstraintSet, - c::MOI.ConstraintIndex{F,MOI.LessThan{T}}, - set::MOI.LessThan{T}, -) where {T,F} - row = c.value - block.g_U[row] = set.upper - return -end - -function MOI.set( - block::QPBlockData{T}, - ::MOI.ConstraintSet, - c::MOI.ConstraintIndex{F,MOI.GreaterThan{T}}, - set::MOI.GreaterThan{T}, -) where {T,F} - row = c.value - block.g_L[row] = set.lower - return -end - -function MOI.set( - block::QPBlockData{T}, - ::MOI.ConstraintSet, - c::MOI.ConstraintIndex{F,MOI.EqualTo{T}}, - set::MOI.EqualTo{T}, -) where {T,F} - row = c.value - block.g_L[row] = set.value - block.g_U[row] = set.value - return -end - -function MOI.set( - block::QPBlockData{T}, - ::MOI.ConstraintSet, - c::MOI.ConstraintIndex{F,MOI.Interval{T}}, - set::MOI.Interval{T}, -) where {T,F} - row = c.value - block.g_L[row] = set.lower - block.g_U[row] = set.upper - return -end - -function MOI.get( - block::QPBlockData{T}, - ::MOI.ConstraintDualStart, - c::MOI.ConstraintIndex{F,S}, -) where {T,F,S} - return block.mult_g[c.value] -end - -function MOI.set( - block::QPBlockData{T}, - ::MOI.ConstraintDualStart, - c::MOI.ConstraintIndex{F,S}, - value, -) where {T,F,S} - block.mult_g[c.value] = value - return -end - -function MOI.eval_objective( - block::QPBlockData{T}, - x::AbstractVector{T}, -) where {T} - return eval_function(block.objective, x, block.parameters) -end - -function MOI.eval_objective_gradient( - block::QPBlockData{T}, - ∇f::AbstractVector{T}, - x::AbstractVector{T}, -) where {T} - ∇f .= zero(T) - eval_dense_gradient(∇f, block.objective, x, block.parameters) - return -end - -function MOI.eval_constraint( - block::QPBlockData{T}, - g::AbstractVector{T}, - x::AbstractVector{T}, -) where {T} - for (i, constraint) in enumerate(block.constraints) - g[i] = eval_function(constraint, x, block.parameters) - end - return -end - -function MOI.jacobian_structure(block::QPBlockData) - J = Tuple{Int,Int}[] - for (row, constraint) in enumerate(block.constraints) - append_sparse_gradient_structure!(constraint, J, row) - end - return J -end - -function MOI.eval_constraint_jacobian( - block::QPBlockData{T}, - J::AbstractVector{T}, - x::AbstractVector{T}, -) where {T} - i = 1 - for constraint in block.constraints - ∇f = view(J, i:length(J)) - i += eval_sparse_gradient(∇f, constraint, x, block.parameters) - end - return i -end - -function MOI.hessian_lagrangian_structure(block::QPBlockData) - H = Tuple{Int,Int}[] - append_sparse_hessian_structure!(block.objective, H) - for constraint in block.constraints - append_sparse_hessian_structure!(constraint, H) - end - return H -end - -function MOI.eval_hessian_lagrangian( - block::QPBlockData{T}, - H::AbstractVector{T}, - x::AbstractVector{T}, - σ::T, - μ::AbstractVector{T}, -) where {T} - i = 1 - i += eval_sparse_hessian(H, block.objective, σ) - for (row, constraint) in enumerate(block.constraints) - ∇²f = view(H, i:length(H)) - i += eval_sparse_hessian(∇²f, constraint, μ[row]) - end - return i -end From d9c5234239debb8806ef43faabfd8d69a476a44d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Beno=C3=AEt=20Legat?= Date: Thu, 13 Aug 2026 12:25:38 +0200 Subject: [PATCH 2/5] MOI --- .github/workflows/ci.yml | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 58e33da..659c538 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -41,6 +41,13 @@ jobs: version: ${{ matrix.version }} arch: ${{ matrix.arch }} - uses: julia-actions/cache@v3 + - name: MOI + shell: julia --project=@. {0} + run: | + using Pkg + Pkg.add([ + PackageSpec(name="MathOptInterface", rev="bl/qp_block_data"), + ]) - uses: julia-actions/julia-buildpkg@v1 - uses: julia-actions/julia-runtest@v1 env: From dfc5efb88e34f493d7e2273e96c899e464283100 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Beno=C3=AEt=20Legat?= Date: Thu, 13 Aug 2026 10:45:14 +0000 Subject: [PATCH 3/5] Track the QP block entry counts in the Optimizer The evaluator methods of MOI.Nonlinear.QPBlockData now return nothing, following the documented contract of MOI.eval_constraint_jacobian and MOI.eval_hessian_lagrangian, so the offsets of the oracle and NLP blocks are computed once in _setup_model instead. --- ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl b/ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl index cea2213..58d9712 100644 --- a/ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl +++ b/ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl @@ -54,6 +54,10 @@ mutable struct Optimizer <: MOI.AbstractOptimizer nlp_dual_start::Union{Nothing,Vector{Float64}} mult_g_nlp::Dict{MOI.Nonlinear.ConstraintIndex,Float64} qp_data::QPBlockData{Float64} + # The number of entries of the Jacobian and of the Hessian of the + # Lagrangian of `qp_data`, computed in `_setup_model`. + qp_nnzj::Int + qp_nnzh::Int nlp_model::Union{Nothing,MOI.Nonlinear.Model} callback::Union{Nothing,Function} barrier_iterations::Int @@ -85,6 +89,8 @@ mutable struct Optimizer <: MOI.AbstractOptimizer nothing, Dict{MOI.Nonlinear.ConstraintIndex,Float64}(), QPBlockData{Float64}(), + 0, + 0, nothing, nothing, 0, @@ -137,6 +143,8 @@ function MOI.empty!(model::Optimizer) model.nlp_dual_start = nothing empty!(model.mult_g_nlp) model.qp_data = QPBlockData{Float64}() + model.qp_nnzj = 0 + model.qp_nnzh = 0 model.nlp_model = nothing model.callback = nothing model.barrier_iterations = 0 @@ -1187,7 +1195,8 @@ function _eval_constraint_jacobian( end function MOI.eval_constraint_jacobian(model::Optimizer, values, x) - offset = MOI.eval_constraint_jacobian(model.qp_data, values, x) + MOI.eval_constraint_jacobian(model.qp_data, values, x) + offset = model.qp_nnzj for (f, s) in model.vector_nonlinear_oracle_constraints offset = _eval_constraint_jacobian(values, offset, x, f, s) end @@ -1239,7 +1248,8 @@ function _eval_hessian_lagrangian( end function MOI.eval_hessian_lagrangian(model::Optimizer, H, x, σ, μ) - offset = MOI.eval_hessian_lagrangian(model.qp_data, H, x, σ, μ) + MOI.eval_hessian_lagrangian(model.qp_data, H, x, σ, μ) + offset = model.qp_nnzh μ_offset = length(model.qp_data) for (f, s) in model.vector_nonlinear_oracle_constraints offset, μ_offset = @@ -1380,6 +1390,8 @@ function _setup_model(model::Optimizer) MOI.Nonlinear.Evaluator(model.nlp_model, model.ad_backend, vars), ) end + model.qp_nnzj = length(MOI.jacobian_structure(model.qp_data)) + model.qp_nnzh = length(MOI.hessian_lagrangian_structure(model.qp_data)) has_quadratic_constraints = any( isequal(MOI.Nonlinear._kFunctionTypeScalarQuadratic), From 019732de68aca0a8857ac32c9e999c2e0843f414 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Beno=C3=AEt=20Legat?= Date: Fri, 21 Aug 2026 07:17:50 +0200 Subject: [PATCH 4/5] Use MOI.Nonlinear.ModelWithQuad instead of QPBlockData (#549) * Use MOI.Nonlinear.ModelWithQuad instead of QPBlockData Store the affine and quadratic objective and constraints in a MOI.Nonlinear.ModelWithQuad whose inner model is the nonlinear model (nlp_model now aliases quad_data.inner), and evaluate everything through a MOI.Nonlinear.EvaluatorWithQuad built in _setup_model. The evaluator owns the QP block entry counts, so the qp_nnzj/qp_nnzh fields are removed. The inner evaluator is a new _OracleNLPEvaluator that stacks the VectorNonlinearOracle rows before the NLPBlock rows; it extends the private MOI.Nonlinear._constraint_bounds so that the constraint bounds of the whole stack are assembled by the evaluator. * MOI * Set the quadratic objective with Nonlinear.set_objective MOI.Nonlinear.ModelWithQuad no longer implements MOI.set for the objective; Nonlinear.set_objective is the single way to set it. * Merge the variables, parameters and nonlinear model into one field MOI.Nonlinear.ModelWithQuad now owns the variables (with indices guaranteed to be 1:n) and the parameters of the model, so the variables, parameters, quad_data and nlp_model fields collapse into a single model field that most of the MOI API forwards to. The parameter convention is back to the simple _PARAMETER_OFFSET test, now defined in MOI.Nonlinear, and the parameter values are stored once, in the inner nonlinear model, aliased by the QP block: the per-solve parameter sync is gone. A uses_nlp_block flag replaces the nlp_model !== nothing test to tell the legacy MOI.NLPBlock API apart, because optimize! overwrites nlp_data; the NLPBlock is rebuilt on every setup unless that flag is set, so that a stale objective cannot survive an objective switch. * Use the _is_parameter of MOI.Nonlinear directly Defining the term methods on a local alias of the function pirated it; the term methods are in MOI.Nonlinear now. * Fix * Get rid of list_of_variable_indices --- .github/workflows/ci.yml | 2 +- ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl | 467 +++++++++----------- 2 files changed, 213 insertions(+), 256 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 659c538..e31b020 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -46,7 +46,7 @@ jobs: run: | using Pkg Pkg.add([ - PackageSpec(name="MathOptInterface", rev="bl/qp_block_data"), + PackageSpec(name="MathOptInterface", rev="bl/model_with_quad"), ]) - uses: julia-actions/julia-buildpkg@v1 - uses: julia-actions/julia-runtest@v1 diff --git a/ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl b/ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl index 58d9712..1f9c152 100644 --- a/ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl +++ b/ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl @@ -3,19 +3,6 @@ # 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. -const QPBlockData = MOI.Nonlinear.QPBlockData - - -const _PARAMETER_OFFSET = 0x00f0000000000000 - -_is_parameter(x::MOI.VariableIndex) = x.value >= _PARAMETER_OFFSET - -_is_parameter(term::MOI.ScalarAffineTerm) = _is_parameter(term.variable) - -function _is_parameter(term::MOI.ScalarQuadraticTerm) - return _is_parameter(term.variable_1) || _is_parameter(term.variable_2) -end - mutable struct _VectorNonlinearOracleCache set::MOI.VectorNonlinearOracle{Float64} x::Vector{Float64} @@ -44,21 +31,18 @@ mutable struct Optimizer <: MOI.AbstractOptimizer options::Dict{String,Any} solve_time::Float64 sense::MOI.OptimizationSense - parameters::Dict{MOI.VariableIndex,MOI.Nonlinear.ParameterIndex} - variables::MOI.Utilities.VariablesContainer{Float64} - list_of_variable_indices::Vector{MOI.VariableIndex} + model::MOI.Nonlinear.ModelWithQuad{Float64,MOI.Nonlinear.Model} variable_primal_start::Vector{Union{Nothing,Float64}} mult_x_L::Vector{Union{Nothing,Float64}} mult_x_U::Vector{Union{Nothing,Float64}} nlp_data::MOI.NLPBlockData + # Whether `nlp_data` was set through the legacy `MOI.NLPBlock` API, in + # which case it must not be rebuilt from the inner nonlinear model. + uses_nlp_block::Bool nlp_dual_start::Union{Nothing,Vector{Float64}} mult_g_nlp::Dict{MOI.Nonlinear.ConstraintIndex,Float64} - qp_data::QPBlockData{Float64} - # The number of entries of the Jacobian and of the Hessian of the - # Lagrangian of `qp_data`, computed in `_setup_model`. - qp_nnzj::Int - qp_nnzh::Int - nlp_model::Union{Nothing,MOI.Nonlinear.Model} + # The evaluator of `model`, rebuilt in `_setup_model`. + evaluator::Union{Nothing,MOI.Nonlinear.EvaluatorWithQuad{Float64}} callback::Union{Nothing,Function} barrier_iterations::Int ad_backend::MOI.Nonlinear.AbstractAutomaticDifferentiation @@ -79,18 +63,14 @@ mutable struct Optimizer <: MOI.AbstractOptimizer Dict{String,Any}(), NaN, MOI.FEASIBILITY_SENSE, - Dict{MOI.VariableIndex,Float64}(), - MOI.Utilities.VariablesContainer{Float64}(), - MOI.VariableIndex[], + MOI.Nonlinear.ModelWithQuad(MOI.Nonlinear.Model()), Union{Nothing,Float64}[], Union{Nothing,Float64}[], Union{Nothing,Float64}[], MOI.NLPBlockData([], _EmptyNLPEvaluator(), false), + false, nothing, Dict{MOI.Nonlinear.ConstraintIndex,Float64}(), - QPBlockData{Float64}(), - 0, - 0, nothing, nothing, 0, @@ -133,19 +113,15 @@ function MOI.empty!(model::Optimizer) # SKIP: model.options model.solve_time = 0.0 model.sense = MOI.FEASIBILITY_SENSE - empty!(model.parameters) - MOI.empty!(model.variables) - empty!(model.list_of_variable_indices) + model.model = MOI.Nonlinear.ModelWithQuad(MOI.Nonlinear.Model()) empty!(model.variable_primal_start) empty!(model.mult_x_L) empty!(model.mult_x_U) model.nlp_data = MOI.NLPBlockData([], _EmptyNLPEvaluator(), false) + model.uses_nlp_block = false model.nlp_dual_start = nothing empty!(model.mult_g_nlp) - model.qp_data = QPBlockData{Float64}() - model.qp_nnzj = 0 - model.qp_nnzh = 0 - model.nlp_model = nothing + model.evaluator = nothing model.callback = nothing model.barrier_iterations = 0 # SKIP: model.ad_backend @@ -158,7 +134,7 @@ function MOI.empty!(model::Optimizer) end function MOI.is_empty(model::Optimizer) - return MOI.is_empty(model.variables) && + return MOI.is_empty(model.model.variables) && isempty(model.variable_primal_start) && isempty(model.mult_x_L) && isempty(model.mult_x_U) && @@ -182,12 +158,11 @@ function MOI.supports_add_constrained_variable( return true end -function _init_nlp_model(model) - if model.nlp_model === nothing - if !(model.nlp_data.evaluator isa _EmptyNLPEvaluator) - error("Cannot mix the new and legacy nonlinear APIs") - end - model.nlp_model = MOI.Nonlinear.Model() +# The nonlinear model is `model.model.inner` and always exists; this guard +# only rejects mixing it with the legacy `MOI.NLPBlock` API. +function _check_no_nlp_block(model) + if model.uses_nlp_block + error("Cannot mix the new and legacy nonlinear APIs") end return end @@ -197,17 +172,8 @@ function MOI.add_constrained_variable( set::MOI.Parameter{Float64}, ) model.inner = nothing - _init_nlp_model(model) - p = MOI.VariableIndex(_PARAMETER_OFFSET + length(model.parameters)) - push!(model.list_of_variable_indices, p) - model.parameters[p] = - MOI.Nonlinear.add_parameter(model.nlp_model, set.value) - # `QPBlockData` treats a variable as a parameter if and only if its index - # is a key of `parameters`, so the parameter must be registered before - # any structure query. The value is re-synced in `copy_parameters` before - # every solve. - model.qp_data.parameters[p.value] = set.value - ci = MOI.ConstraintIndex{MOI.VariableIndex,typeof(set)}(p.value) + _check_no_nlp_block(model) + p, ci = MOI.add_constrained_variable(model.model, set) return p, ci end @@ -215,69 +181,26 @@ function MOI.is_valid( model::Optimizer, ci::MOI.ConstraintIndex{MOI.VariableIndex,MOI.Parameter{Float64}}, ) - return haskey(model.parameters, MOI.VariableIndex(ci.value)) + return MOI.is_valid(model.model, ci) end function MOI.get( model::Optimizer, - ::MOI.ListOfConstraintIndices{F,S}, + attr::Union{MOI.ListOfConstraintIndices{F,S},MOI.NumberOfConstraints{F,S}}, ) where {F<:MOI.VariableIndex,S<:MOI.Parameter{Float64}} - ret = [MOI.ConstraintIndex{F,S}(p.value) for p in keys(model.parameters)] - sort!(ret; by = x -> x.value) - return ret -end - -function MOI.get( - model::Optimizer, - ::MOI.NumberOfConstraints{MOI.VariableIndex,MOI.Parameter{Float64}}, -) - return length(model.parameters) + return MOI.get(model.model, attr) end function MOI.set( model::Optimizer, - ::MOI.ConstraintSet, + attr::MOI.ConstraintSet, ci::MOI.ConstraintIndex{MOI.VariableIndex,MOI.Parameter{Float64}}, set::MOI.Parameter{Float64}, ) - p = model.parameters[MOI.VariableIndex(ci.value)] - model.nlp_model[p] = set.value + MOI.set(model.model, attr, ci, set) return end -_replace_parameters(model::Optimizer, f) = f - -function _replace_parameters(model::Optimizer, f::MOI.VariableIndex) - if _is_parameter(f) - return model.parameters[f] - end - return f -end - -function _replace_parameters(model::Optimizer, f::MOI.ScalarAffineFunction) - if any(_is_parameter, f.terms) - g = convert(MOI.ScalarNonlinearFunction, f) - return _replace_parameters(model, g) - end - return f -end - -function _replace_parameters(model::Optimizer, f::MOI.ScalarQuadraticFunction) - if any(_is_parameter, f.affine_terms) || - any(_is_parameter, f.quadratic_terms) - g = convert(MOI.ScalarNonlinearFunction, f) - return _replace_parameters(model, g) - end - return f -end - -function _replace_parameters(model::Optimizer, f::MOI.ScalarNonlinearFunction) - for (i, arg) in enumerate(f.args) - f.args[i] = _replace_parameters(model, arg) - end - return f -end - function MOI.supports_constraint( ::Optimizer, ::Type{ @@ -295,8 +218,6 @@ end ### MOI.ListOfConstraintTypesPresent -_add_scalar_nonlinear_constraints(ret, ::Nothing) = nothing - function _add_scalar_nonlinear_constraints(ret, nlp_model::MOI.Nonlinear.Model) for v in values(nlp_model.constraints) F, S = MOI.ScalarNonlinearFunction, typeof(v.set) @@ -308,13 +229,13 @@ function _add_scalar_nonlinear_constraints(ret, nlp_model::MOI.Nonlinear.Model) end function MOI.get(model::Optimizer, attr::MOI.ListOfConstraintTypesPresent) - ret = MOI.get(model.variables, attr) - append!(ret, MOI.get(model.qp_data, attr)) - _add_scalar_nonlinear_constraints(ret, model.nlp_model) + ret = MOI.get(model.model.variables, attr) + append!(ret, MOI.get(model.model, attr)) + _add_scalar_nonlinear_constraints(ret, model.model.inner) if !isempty(model.vector_nonlinear_oracle_constraints) push!(ret, (MOI.VectorOfVariables, MOI.VectorNonlinearOracle{Float64})) end - if !isempty(model.parameters) + if !isempty(model.model.qp.parameters) push!(ret, (MOI.VariableIndex, MOI.Parameter{Float64})) end return ret @@ -392,31 +313,27 @@ function MOI.add_variable(model::Optimizer) push!(model.mult_x_L, nothing) push!(model.mult_x_U, nothing) model.inner = nothing - x = MOI.add_variable(model.variables) - push!(model.list_of_variable_indices, x) + x = MOI.add_variable(model.model) return x end function MOI.is_valid(model::Optimizer, x::MOI.VariableIndex) - if _is_parameter(x) - return haskey(model.parameters, x) - end - return MOI.is_valid(model.variables, x) + return MOI.is_valid(model.model, x) end -function MOI.get(model::Optimizer, ::MOI.ListOfVariableIndices) - return model.list_of_variable_indices +function MOI.get(model::Optimizer, attr::MOI.ListOfVariableIndices) + return MOI.get(model.model, attr) end -function MOI.get(model::Optimizer, ::MOI.NumberOfVariables) - return length(model.list_of_variable_indices) +function MOI.get(model::Optimizer, attr::MOI.NumberOfVariables) + return MOI.get(model.model, attr) end function MOI.is_valid( model::Optimizer, ci::MOI.ConstraintIndex{MOI.VariableIndex,<:_SETS}, ) - return MOI.is_valid(model.variables, ci) + return MOI.is_valid(model.model.variables, ci) end function MOI.get( @@ -426,7 +343,7 @@ function MOI.get( MOI.ListOfConstraintIndices{MOI.VariableIndex,<:_SETS}, }, ) - return MOI.get(model.variables, attr) + return MOI.get(model.model.variables, attr) end function MOI.get( @@ -434,11 +351,11 @@ function MOI.get( attr::Union{MOI.ConstraintFunction,MOI.ConstraintSet}, c::MOI.ConstraintIndex{MOI.VariableIndex,<:_SETS}, ) - return MOI.get(model.variables, attr, c) + return MOI.get(model.model.variables, attr, c) end function MOI.add_constraint(model::Optimizer, x::MOI.VariableIndex, set::_SETS) - index = MOI.add_constraint(model.variables, x, set) + index = MOI.add_constraint(model.model.variables, x, set) model.inner = nothing return index end @@ -449,7 +366,7 @@ function MOI.set( ci::MOI.ConstraintIndex{MOI.VariableIndex,S}, set::S, ) where {S<:_SETS} - MOI.set(model.variables, MOI.ConstraintSet(), ci, set) + MOI.set(model.model.variables, MOI.ConstraintSet(), ci, set) model.needs_new_inner = true return end @@ -458,7 +375,7 @@ function MOI.delete( model::Optimizer, ci::MOI.ConstraintIndex{MOI.VariableIndex,<:_SETS}, ) - MOI.delete(model.variables, ci) + MOI.delete(model.model.variables, ci) model.inner = nothing return end @@ -474,7 +391,7 @@ function MOI.is_valid( MOI.ScalarQuadraticFunction{Float64}, }, } - return MOI.is_valid(model.qp_data, ci) + return MOI.is_valid(model.model, ci) end function MOI.add_constraint( @@ -485,7 +402,7 @@ function MOI.add_constraint( }, set::_SETS, ) - index = MOI.add_constraint(model.qp_data, func, set) + index = MOI.add_constraint(model.model, func, set) model.inner = nothing return index end @@ -500,7 +417,7 @@ function MOI.get( }, S<:_SETS, } - return MOI.get(model.qp_data, attr) + return MOI.get(model.model, attr) end function MOI.get( @@ -513,7 +430,7 @@ function MOI.get( MOI.ScalarQuadraticFunction{Float64}, }, } - return MOI.get(model.qp_data, attr, c) + return MOI.get(model.model, attr, c) end function MOI.set( @@ -528,7 +445,7 @@ function MOI.set( }, S<:_SETS, } - MOI.set(model.qp_data, MOI.ConstraintSet(), ci, set) + MOI.set(model.model, MOI.ConstraintSet(), ci, set) model.needs_new_inner = true return end @@ -556,7 +473,7 @@ function MOI.get( MOI.ScalarQuadraticFunction{Float64}, }, } - return MOI.get(model.qp_data, attr, c) + return MOI.get(model.model, attr, c) end function MOI.set( @@ -571,7 +488,7 @@ function MOI.set( }, } MOI.throw_if_not_valid(model, ci) - MOI.set(model.qp_data, attr, ci, value) + MOI.set(model.model, attr, ci, value) # No need to reset model.inner, because this gets handled in optimize!. return end @@ -582,11 +499,8 @@ function MOI.is_valid( model::Optimizer, ci::MOI.ConstraintIndex{MOI.ScalarNonlinearFunction,<:_SETS}, ) - if model.nlp_model === nothing - return false - end index = MOI.Nonlinear.ConstraintIndex(ci.value) - return MOI.is_valid(model.nlp_model, index) + return MOI.is_valid(model.model.inner, index) end function MOI.get( @@ -594,10 +508,7 @@ function MOI.get( attr::MOI.ListOfConstraintIndices{F,S}, ) where {F<:MOI.ScalarNonlinearFunction,S<:_SETS} ret = MOI.ConstraintIndex{F,S}[] - if model.nlp_model === nothing - return ret - end - for (k, v) in model.nlp_model.constraints + for (k, v) in model.model.inner.constraints if v.set isa S push!(ret, MOI.ConstraintIndex{F,S}(k.value)) end @@ -609,10 +520,7 @@ function MOI.get( model::Optimizer, attr::MOI.NumberOfConstraints{F,S}, ) where {F<:MOI.ScalarNonlinearFunction,S<:_SETS} - if model.nlp_model === nothing - return 0 - end - return count(v.set isa S for v in values(model.nlp_model.constraints)) + return count(v.set isa S for v in values(model.model.inner.constraints)) end function MOI.add_constraint( @@ -620,11 +528,8 @@ function MOI.add_constraint( f::MOI.ScalarNonlinearFunction, s::_SETS, ) - _init_nlp_model(model) - if !isempty(model.parameters) - _replace_parameters(model, f) - end - index = MOI.Nonlinear.add_constraint(model.nlp_model, f, s) + _check_no_nlp_block(model) + index = MOI.Nonlinear.add_constraint(model.model, f, s) model.inner = nothing return MOI.ConstraintIndex{typeof(f),typeof(s)}(index.value) end @@ -641,11 +546,8 @@ function MOI.set( attr::MOI.ObjectiveFunction{MOI.ScalarNonlinearFunction}, func::MOI.ScalarNonlinearFunction, ) - _init_nlp_model(model) - if !isempty(model.parameters) - _replace_parameters(model, func) - end - MOI.Nonlinear.set_objective(model.nlp_model, func) + _check_no_nlp_block(model) + MOI.Nonlinear.set_objective(model.model, func) model.inner = nothing return end @@ -657,7 +559,7 @@ function MOI.get( ) MOI.throw_if_not_valid(model, ci) index = MOI.Nonlinear.ConstraintIndex(ci.value) - return model.nlp_model[index].set + return model.model.inner[index].set end function MOI.set( @@ -668,8 +570,8 @@ function MOI.set( ) where {S<:_SETS} MOI.throw_if_not_valid(model, ci) index = MOI.Nonlinear.ConstraintIndex(ci.value) - func = model.nlp_model[index].expression - model.nlp_model.constraints[index] = MOI.Nonlinear.Constraint(func, set) + func = model.model.inner[index].expression + model.model.inner.constraints[index] = MOI.Nonlinear.Constraint(func, set) model.needs_new_inner = true return end @@ -760,7 +662,7 @@ function row( model::Optimizer, ci::MOI.ConstraintIndex{F,S}, ) where {F<:MOI.VectorOfVariables,S<:MOI.VectorNonlinearOracle{Float64}} - offset = length(model.qp_data) + offset = length(model.model) for i in 1:(ci.value-1) _, s = model.vector_nonlinear_oracle_constraints[i] offset += s.set.output_dimension @@ -846,9 +748,9 @@ end MOI.supports(model::Optimizer, ::MOI.UserDefinedFunction) = true function MOI.set(model::Optimizer, attr::MOI.UserDefinedFunction, args) - _init_nlp_model(model) + _check_no_nlp_block(model) MOI.Nonlinear.register_operator( - model.nlp_model, + model.model.inner, attr.name, attr.arity, args..., @@ -859,8 +761,7 @@ end ### ListOfSupportedNonlinearOperators function MOI.get(model::Optimizer, attr::MOI.ListOfSupportedNonlinearOperators) - _init_nlp_model(model) - return MOI.get(model.nlp_model, attr) + return MOI.get(model.model, attr) end ### MOI.VariablePrimalStart @@ -878,7 +779,7 @@ function MOI.get( attr::MOI.VariablePrimalStart, vi::MOI.VariableIndex, ) - if _is_parameter(vi) + if MOI.Nonlinear._is_parameter(vi) throw(MOI.GetAttributeNotAllowed(attr, "Variable is a Parameter")) end MOI.throw_if_not_valid(model, vi) @@ -891,7 +792,7 @@ function MOI.set( vi::MOI.VariableIndex, value::Union{Real,Nothing}, ) - if _is_parameter(vi) + if MOI.Nonlinear._is_parameter(vi) throw(MOI.SetAttributeNotAllowed(attr, "Variable is a Parameter")) end MOI.throw_if_not_valid(model, vi) @@ -1015,10 +916,11 @@ MOI.supports(::Optimizer, ::MOI.NLPBlock) = true MOI.get(model::Optimizer, ::MOI.NLPBlock) = model.nlp_data function MOI.set(model::Optimizer, ::MOI.NLPBlock, nlp_data::MOI.NLPBlockData) - if model.nlp_model !== nothing + if !MOI.is_empty(model.model.inner) error("Cannot mix the new and legacy nonlinear APIs") end model.nlp_data = nlp_data + model.uses_nlp_block = !(nlp_data.evaluator isa _EmptyNLPEvaluator) model.inner = nothing return end @@ -1042,10 +944,10 @@ MOI.get(model::Optimizer, ::MOI.ObjectiveSense) = model.sense ### ObjectiveFunction function MOI.get(model::Optimizer, attr::MOI.ObjectiveFunctionType) - if model.nlp_model !== nothing && model.nlp_model.objective !== nothing + if model.model.inner.objective !== nothing return MOI.ScalarNonlinearFunction end - return MOI.get(model.qp_data, attr) + return MOI.get(model.model, attr) end function MOI.supports( @@ -1071,7 +973,7 @@ function MOI.get( MOI.ScalarQuadraticFunction{Float64}, }, } - return convert(F, MOI.get(model.qp_data, attr)) + return convert(F, MOI.get(model.model, attr)) end function MOI.set( @@ -1085,14 +987,72 @@ function MOI.set( MOI.ScalarQuadraticFunction{Float64}, }, } - MOI.set(model.qp_data, attr, func) - if model.nlp_model !== nothing - MOI.Nonlinear.set_objective(model.nlp_model, nothing) - end + # This also clears any objective of the inner nonlinear model. + MOI.Nonlinear.set_objective(model.model, func) model.inner = nothing return end +### _OracleNLPEvaluator + +""" + _OracleNLPEvaluator(model::Optimizer) + +The inner evaluator of the `MOI.Nonlinear.EvaluatorWithQuad` of `model`: the +rows of the `MOI.VectorNonlinearOracle` constraints followed by the rows of +the `MOI.NLPBlock` evaluator. +""" +struct _OracleNLPEvaluator{E<:MOI.AbstractNLPEvaluator} <: + MOI.AbstractNLPEvaluator + oracles::Vector{Tuple{MOI.VectorOfVariables,_VectorNonlinearOracleCache}} + nlp::E + nlp_bounds::Vector{MOI.NLPBoundsPair} + has_objective::Bool +end + +function _OracleNLPEvaluator(model::Optimizer) + return _OracleNLPEvaluator( + model.vector_nonlinear_oracle_constraints, + model.nlp_data.evaluator, + model.nlp_data.constraint_bounds, + model.nlp_data.has_objective, + ) +end + +function MOI.features_available(d::_OracleNLPEvaluator) + features = MOI.features_available(d.nlp) + if any(s.set.eval_hessian_lagrangian === nothing for (_, s) in d.oracles) + features = setdiff(features, [:Hess, :HessVec]) + end + if !isempty(d.oracles) + # The oracles do not implement the Jacobian and Hessian products. + features = setdiff(features, [:JacVec, :HessVec]) + end + return features +end + +function MOI.initialize(d::_OracleNLPEvaluator, features::Vector{Symbol}) + return MOI.initialize(d.nlp, features) +end + +MOI.eval_objective(d::_OracleNLPEvaluator, x) = MOI.eval_objective(d.nlp, x) + +function MOI.eval_objective_gradient(d::_OracleNLPEvaluator, grad, x) + return MOI.eval_objective_gradient(d.nlp, grad, x) +end + +function MOI.Nonlinear._constraint_bounds(d::_OracleNLPEvaluator) + bounds = MOI.NLPBoundsPair[] + for (_, s) in d.oracles + for i in 1:s.set.output_dimension + push!(bounds, MOI.NLPBoundsPair(s.set.l[i], s.set.u[i])) + end + end + return append!(bounds, d.nlp_bounds) +end + +MOI.Nonlinear._has_objective(d::_OracleNLPEvaluator) = d.has_objective + ### Eval_F_CB function MOI.eval_objective(model::Optimizer, x) @@ -1103,7 +1063,7 @@ function MOI.eval_objective(model::Optimizer, x) elseif model.nlp_data.has_objective return MOI.eval_objective(model.nlp_data.evaluator, x)::Float64 end - return MOI.eval_objective(model.qp_data, x) + return MOI.eval_objective(model.evaluator, x) end ### Eval_Grad_F_CB @@ -1114,7 +1074,7 @@ function MOI.eval_objective_gradient(model::Optimizer, grad, x) elseif model.nlp_data.has_objective MOI.eval_objective_gradient(model.nlp_data.evaluator, grad, x) else - MOI.eval_objective_gradient(model.qp_data, grad, x) + MOI.eval_objective_gradient(model.evaluator, grad, x) end return end @@ -1136,17 +1096,19 @@ function _eval_constraint( return offset + s.set.output_dimension end -function MOI.eval_constraint(model::Optimizer, g, x) - MOI.eval_constraint(model.qp_data, g, x) - offset = length(model.qp_data) - for (f, s) in model.vector_nonlinear_oracle_constraints +function MOI.eval_constraint(d::_OracleNLPEvaluator, g, x) + offset = 0 + for (f, s) in d.oracles offset = _eval_constraint(g, offset, x, f, s) end - g_nlp = view(g, (offset+1):length(g)) - MOI.eval_constraint(model.nlp_data.evaluator, g_nlp, x) + MOI.eval_constraint(d.nlp, view(g, (offset+1):length(g)), x) return end +function MOI.eval_constraint(model::Optimizer, g, x) + return MOI.eval_constraint(model.evaluator, g, x) +end + ### Eval_Jac_G_CB function _jacobian_structure( @@ -1161,16 +1123,14 @@ function _jacobian_structure( return row_offset + s.set.output_dimension end -function MOI.jacobian_structure(model::Optimizer) - J = MOI.jacobian_structure(model.qp_data) - offset = length(model.qp_data) - for (f, s) in model.vector_nonlinear_oracle_constraints +function MOI.jacobian_structure(d::_OracleNLPEvaluator) + J = Tuple{Int,Int}[] + offset = 0 + for (f, s) in d.oracles offset = _jacobian_structure(J, offset, f, s) end - if length(model.nlp_data.constraint_bounds) > 0 - J_nlp = MOI.jacobian_structure( - model.nlp_data.evaluator, - )::Vector{Tuple{Int64,Int64}} + if length(d.nlp_bounds) > 0 + J_nlp = MOI.jacobian_structure(d.nlp)::Vector{Tuple{Int64,Int64}} for (row, col) in J_nlp push!(J, (row + offset, col)) end @@ -1178,6 +1138,10 @@ function MOI.jacobian_structure(model::Optimizer) return J end +function MOI.jacobian_structure(model::Optimizer) + return MOI.jacobian_structure(model.evaluator) +end + function _eval_constraint_jacobian( values::AbstractVector, offset::Int, @@ -1194,17 +1158,20 @@ function _eval_constraint_jacobian( return offset + nnz end -function MOI.eval_constraint_jacobian(model::Optimizer, values, x) - MOI.eval_constraint_jacobian(model.qp_data, values, x) - offset = model.qp_nnzj - for (f, s) in model.vector_nonlinear_oracle_constraints +function MOI.eval_constraint_jacobian(d::_OracleNLPEvaluator, values, x) + offset = 0 + for (f, s) in d.oracles offset = _eval_constraint_jacobian(values, offset, x, f, s) end nlp_values = view(values, (offset+1):length(values)) - MOI.eval_constraint_jacobian(model.nlp_data.evaluator, nlp_values, x) + MOI.eval_constraint_jacobian(d.nlp, nlp_values, x) return end +function MOI.eval_constraint_jacobian(model::Optimizer, values, x) + return MOI.eval_constraint_jacobian(model.evaluator, values, x) +end + ### Eval_H_CB function _hessian_lagrangian_structure( @@ -1218,15 +1185,19 @@ function _hessian_lagrangian_structure( return end -function MOI.hessian_lagrangian_structure(model::Optimizer) - H = MOI.hessian_lagrangian_structure(model.qp_data) - for (f, s) in model.vector_nonlinear_oracle_constraints +function MOI.hessian_lagrangian_structure(d::_OracleNLPEvaluator) + H = Tuple{Int,Int}[] + for (f, s) in d.oracles _hessian_lagrangian_structure(H, f, s) end - append!(H, MOI.hessian_lagrangian_structure(model.nlp_data.evaluator)) + append!(H, MOI.hessian_lagrangian_structure(d.nlp)) return H end +function MOI.hessian_lagrangian_structure(model::Optimizer) + return MOI.hessian_lagrangian_structure(model.evaluator) +end + function _eval_hessian_lagrangian( H::AbstractVector, H_offset::Int, @@ -1247,20 +1218,22 @@ function _eval_hessian_lagrangian( return H_offset + H_nnz, μ_offset + s.set.output_dimension end -function MOI.eval_hessian_lagrangian(model::Optimizer, H, x, σ, μ) - MOI.eval_hessian_lagrangian(model.qp_data, H, x, σ, μ) - offset = model.qp_nnzh - μ_offset = length(model.qp_data) - for (f, s) in model.vector_nonlinear_oracle_constraints +function MOI.eval_hessian_lagrangian(d::_OracleNLPEvaluator, H, x, σ, μ) + offset, μ_offset = 0, 0 + for (f, s) in d.oracles offset, μ_offset = _eval_hessian_lagrangian(H, offset, x, μ, μ_offset, f, s) end H_nlp = view(H, (offset+1):length(H)) μ_nlp = view(μ, (μ_offset+1):length(μ)) - MOI.eval_hessian_lagrangian(model.nlp_data.evaluator, H_nlp, x, σ, μ_nlp) + MOI.eval_hessian_lagrangian(d.nlp, H_nlp, x, σ, μ_nlp) return end +function MOI.eval_hessian_lagrangian(model::Optimizer, H, x, σ, μ) + return MOI.eval_hessian_lagrangian(model.evaluator, H, x, σ, μ) +end + ### MOI.AutomaticDifferentiationBackend MOI.supports(::Optimizer, ::MOI.AutomaticDifferentiationBackend) = true @@ -1310,23 +1283,17 @@ function _setup_inner(model::Optimizer)::Ipopt.IpoptProblem if !model.needs_new_inner return model.inner end - g_L, g_U = copy(model.qp_data.g_L), copy(model.qp_data.g_U) - for (_, s) in model.vector_nonlinear_oracle_constraints - append!(g_L, s.set.l) - append!(g_U, s.set.u) - end - for bound in model.nlp_data.constraint_bounds - push!(g_L, bound.lower) - push!(g_U, bound.upper) - end + bounds = MOI.Nonlinear._constraint_bounds(model.evaluator) + g_L = Float64[b.lower for b in bounds] + g_U = Float64[b.upper for b in bounds] function eval_h_cb(x, rows, cols, obj_factor, lambda, values) return _eval_h_cb(model, x, rows, cols, obj_factor, lambda, values) end has_hessian = model.hessian_sparsity !== nothing model.inner = Ipopt.CreateIpoptProblem( - length(model.variables.lower), - model.variables.lower, - model.variables.upper, + length(model.model.variables.lower), + model.model.variables.lower, + model.model.variables.upper, length(g_L), g_L, g_U, @@ -1384,29 +1351,25 @@ function _setup_model(model::Optimizer) model.invalid_model = true return end - if model.nlp_model !== nothing - vars = MOI.get(model.variables, MOI.ListOfVariableIndices()) + # Rebuild even when the inner model is empty: a previous solve may have + # left a stale `nlp_data` (for example, a nonlinear objective replaced by + # a quadratic one). + if !model.uses_nlp_block + vars = MOI.get(model.model.variables, MOI.ListOfVariableIndices()) model.nlp_data = MOI.NLPBlockData( - MOI.Nonlinear.Evaluator(model.nlp_model, model.ad_backend, vars), + MOI.Nonlinear.Evaluator(model.model.inner, model.ad_backend, vars), ) end - model.qp_nnzj = length(MOI.jacobian_structure(model.qp_data)) - model.qp_nnzh = length(MOI.hessian_lagrangian_structure(model.qp_data)) - has_quadratic_constraints = - any( - isequal(MOI.Nonlinear._kFunctionTypeScalarQuadratic), - model.qp_data.function_type, - ) + model.evaluator = + MOI.Nonlinear.EvaluatorWithQuad(model.model, _OracleNLPEvaluator(model)) + has_quadratic_constraints = any( + isequal(MOI.Nonlinear._kFunctionTypeScalarQuadratic), + model.model.qp.function_type, + ) has_nlp_constraints = !isempty(model.nlp_data.constraint_bounds) || !isempty(model.vector_nonlinear_oracle_constraints) - has_hessian = :Hess in MOI.features_available(model.nlp_data.evaluator) - for (_, s) in model.vector_nonlinear_oracle_constraints - if s.set.eval_hessian_lagrangian === nothing - has_hessian = false - break - end - end + has_hessian = :Hess in MOI.features_available(model.evaluator) init_feat = [:Grad] if has_hessian push!(init_feat, :Hess) @@ -1414,7 +1377,7 @@ function _setup_model(model::Optimizer) if has_nlp_constraints push!(init_feat, :Jac) end - MOI.initialize(model.nlp_data.evaluator, init_feat) + MOI.initialize(model.evaluator, init_feat) model.jacobian_sparsity = MOI.jacobian_structure(model) model.hessian_sparsity = nothing if has_hessian @@ -1435,12 +1398,6 @@ function MOI.optimize!(model::Optimizer) return end inner = _setup_inner(model) - if model.nlp_model !== nothing - empty!(model.qp_data.parameters) - for (p, index) in model.parameters - model.qp_data.parameters[p.value] = model.nlp_model[index] - end - end # The default print level is `5` Ipopt.AddIpoptIntOption(inner, "print_level", model.silent ? 0 : 5) # Other misc options that over-ride the ones set above. @@ -1464,13 +1421,17 @@ function MOI.optimize!(model::Optimizer) for i in 1:length(model.variable_primal_start) inner.x[i] = something( model.variable_primal_start[i], - clamp(0.0, model.variables.lower[i], model.variables.upper[i]), + clamp( + 0.0, + model.model.variables.lower[i], + model.model.variables.upper[i], + ), ) end - for (i, start) in enumerate(model.qp_data.mult_g) + for (i, start) in enumerate(model.model.qp.mult_g) inner.mult_g[i] = _dual_start(model, start, -1) end - offset = length(model.qp_data.mult_g) + offset = length(model.model.qp.mult_g) if model.nlp_dual_start === nothing inner.mult_g[(offset+1):end] .= 0.0 # First there is VectorNonlinearOracle... @@ -1569,16 +1530,10 @@ end function _manually_evaluated_primal_status(model::Optimizer) x, g = model.inner.x, model.inner.g - x_L, x_U = model.variables.lower, model.variables.upper - g_L, g_U = copy(model.qp_data.g_L), copy(model.qp_data.g_U) - for (_, cache) in model.vector_nonlinear_oracle_constraints - append!(g_L, cache.set.l) - append!(g_U, cache.set.u) - end - for bound in model.nlp_data.constraint_bounds - push!(g_L, bound.lower) - push!(g_U, bound.upper) - end + x_L, x_U = model.model.variables.lower, model.model.variables.upper + bounds = MOI.Nonlinear._constraint_bounds(model.evaluator) + g_L = Float64[b.lower for b in bounds] + g_U = Float64[b.upper for b in bounds] m, n = length(g_L), length(x) # 1e-8 is the default tolerance tol = get(model.options, "tol", 1e-8) @@ -1642,9 +1597,11 @@ function MOI.get( ) MOI.check_result_index_bounds(model, attr) MOI.throw_if_not_valid(model, vi) - if _is_parameter(vi) - p = model.parameters[vi] - return model.nlp_model[p] + if MOI.Nonlinear._is_parameter(vi) + ci = MOI.ConstraintIndex{MOI.VariableIndex,MOI.Parameter{Float64}}( + vi.value, + ) + return MOI.get(model.model, MOI.ConstraintSet(), ci).value end return model.inner.x[Ipopt.column(vi)] end @@ -1667,7 +1624,7 @@ function row( model::Optimizer, ci::MOI.ConstraintIndex{MOI.ScalarNonlinearFunction}, ) - offset = length(model.qp_data) + offset = length(model.model) for (_, s) in model.vector_nonlinear_oracle_constraints offset += s.set.output_dimension end @@ -1770,7 +1727,7 @@ end function MOI.get(model::Optimizer, attr::MOI.NLPBlockDual) MOI.check_result_index_bounds(model, attr) s = -_dual_multiplier(model) - return s .* model.inner.mult_g[(length(model.qp_data)+1):end] + return s .* model.inner.mult_g[(length(model.model)+1):end] end ### Ipopt.CallbackFunction From 9519e5f49fe62602cfa3f391e47532987c1146c6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Beno=C3=AEt=20Legat?= Date: Fri, 21 Aug 2026 07:31:52 +0200 Subject: [PATCH 5/5] MOI --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e31b020..659c538 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -46,7 +46,7 @@ jobs: run: | using Pkg Pkg.add([ - PackageSpec(name="MathOptInterface", rev="bl/model_with_quad"), + PackageSpec(name="MathOptInterface", rev="bl/qp_block_data"), ]) - uses: julia-actions/julia-buildpkg@v1 - uses: julia-actions/julia-runtest@v1