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/7] 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/7] 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/7] 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/7] 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/7] 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 From 977c2244892a52937ee9d0200e4929ea26954c64 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Beno=C3=AEt=20Legat?= Date: Sun, 6 Sep 2026 09:30:29 +0200 Subject: [PATCH 6/7] Use MOI api with NL model --- ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl | 1148 ++++--------------- test/MOI_wrapper.jl | 20 +- 2 files changed, 219 insertions(+), 949 deletions(-) diff --git a/ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl b/ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl index 1f9c152..5e3555a 100644 --- a/ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl +++ b/ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl @@ -3,21 +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. -mutable struct _VectorNonlinearOracleCache - set::MOI.VectorNonlinearOracle{Float64} - x::Vector{Float64} - start::Union{Nothing,Vector{Float64}} - eval_f_timer::Float64 - eval_jacobian_timer::Float64 - eval_hessian_lagrangian_timer::Float64 - - function _VectorNonlinearOracleCache( - set::MOI.VectorNonlinearOracle{Float64}, - ) - return new(set, zeros(set.input_dimension), nothing, 0.0, 0.0, 0.0) - end -end - """ Optimizer() @@ -30,8 +15,10 @@ mutable struct Optimizer <: MOI.AbstractOptimizer silent::Bool options::Dict{String,Any} solve_time::Float64 - sense::MOI.OptimizationSense - model::MOI.Nonlinear.ModelWithQuad{Float64,MOI.Nonlinear.Model} + model::MOI.Nonlinear.ModelWithQuad{ + Float64, + MOI.Nonlinear.ModelWithOracles{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}} @@ -40,15 +27,11 @@ mutable struct Optimizer <: MOI.AbstractOptimizer # 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} # The evaluator of `model`, rebuilt in `_setup_model`. - evaluator::Union{Nothing,MOI.Nonlinear.EvaluatorWithQuad{Float64}} + evaluator::Union{Nothing,MOI.AbstractNLPEvaluator} callback::Union{Nothing,Function} barrier_iterations::Int ad_backend::MOI.Nonlinear.AbstractAutomaticDifferentiation - vector_nonlinear_oracle_constraints::Vector{ - Tuple{MOI.VectorOfVariables,_VectorNonlinearOracleCache}, - } jacobian_sparsity::Vector{Tuple{Int,Int}} hessian_sparsity::Union{Nothing,Vector{Tuple{Int,Int}}} needs_new_inner::Bool @@ -62,20 +45,19 @@ mutable struct Optimizer <: MOI.AbstractOptimizer false, Dict{String,Any}(), NaN, - MOI.FEASIBILITY_SENSE, - MOI.Nonlinear.ModelWithQuad(MOI.Nonlinear.Model()), + MOI.Nonlinear.ModelWithQuad( + MOI.Nonlinear.ModelWithOracles(MOI.Nonlinear.Model()), + ), Union{Nothing,Float64}[], Union{Nothing,Float64}[], Union{Nothing,Float64}[], MOI.NLPBlockData([], _EmptyNLPEvaluator(), false), false, nothing, - Dict{MOI.Nonlinear.ConstraintIndex,Float64}(), nothing, nothing, 0, MOI.Nonlinear.SparseReverseMode(), - Tuple{MOI.VectorOfVariables,_VectorNonlinearOracleCache}[], Tuple{Int,Int}[], nothing, true, @@ -105,6 +87,39 @@ MOI.hessian_lagrangian_structure(::_EmptyNLPEvaluator) = Tuple{Int64,Int64}[] MOI.eval_constraint_jacobian(::_EmptyNLPEvaluator, J, x) = nothing MOI.eval_hessian_lagrangian(::_EmptyNLPEvaluator, H, x, σ, μ) = nothing +struct _NLPBlockEvaluator <: MOI.AbstractNLPEvaluator + data::MOI.NLPBlockData + sense::MOI.OptimizationSense +end + +MOI.features_available(d::_NLPBlockEvaluator) = + MOI.features_available(d.data.evaluator) +MOI.initialize(d::_NLPBlockEvaluator, features) = + MOI.initialize(d.data.evaluator, features) +MOI.Nonlinear._constraint_bounds(d::_NLPBlockEvaluator) = + d.data.constraint_bounds +MOI.Nonlinear._has_objective(d::_NLPBlockEvaluator) = d.data.has_objective +MOI.eval_objective(d::_NLPBlockEvaluator, x) = + MOI.Nonlinear._objective_sign(d.sense) * + MOI.eval_objective(d.data.evaluator, x) +function MOI.eval_objective_gradient(d::_NLPBlockEvaluator, g, x) + MOI.eval_objective_gradient(d.data.evaluator, g, x) + g .*= MOI.Nonlinear._objective_sign(d.sense) + return +end +MOI.eval_constraint(d::_NLPBlockEvaluator, g, x) = + MOI.eval_constraint(d.data.evaluator, g, x) +MOI.jacobian_structure(d::_NLPBlockEvaluator) = + MOI.jacobian_structure(d.data.evaluator) +MOI.eval_constraint_jacobian(d::_NLPBlockEvaluator, J, x) = + MOI.eval_constraint_jacobian(d.data.evaluator, J, x) +MOI.hessian_lagrangian_structure(d::_NLPBlockEvaluator) = + MOI.hessian_lagrangian_structure(d.data.evaluator) +function MOI.eval_hessian_lagrangian(d::_NLPBlockEvaluator, H, x, σ, μ) + sign = MOI.Nonlinear._objective_sign(d.sense) + return MOI.eval_hessian_lagrangian(d.data.evaluator, H, x, sign * σ, μ) +end + function MOI.empty!(model::Optimizer) model.inner = nothing # SKIP: model.name @@ -112,20 +127,19 @@ function MOI.empty!(model::Optimizer) # SKIP: model.silent # SKIP: model.options model.solve_time = 0.0 - model.sense = MOI.FEASIBILITY_SENSE - model.model = MOI.Nonlinear.ModelWithQuad(MOI.Nonlinear.Model()) + model.model = MOI.Nonlinear.ModelWithQuad( + MOI.Nonlinear.ModelWithOracles(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.evaluator = nothing model.callback = nothing model.barrier_iterations = 0 # SKIP: model.ad_backend - empty!(model.vector_nonlinear_oracle_constraints) empty!(model.jacobian_sparsity) model.hessian_sparsity = nothing model.needs_new_inner = true @@ -134,13 +148,13 @@ function MOI.empty!(model::Optimizer) end function MOI.is_empty(model::Optimizer) - return MOI.is_empty(model.model.variables) && + return MOI.get(model.model, MOI.NumberOfVariables()) == 0 && + isempty(MOI.get(model.model, MOI.ListOfConstraintTypesPresent())) && isempty(model.variable_primal_start) && isempty(model.mult_x_L) && isempty(model.mult_x_U) && model.nlp_data.evaluator isa _EmptyNLPEvaluator && - model.sense == MOI.FEASIBILITY_SENSE && - isempty(model.vector_nonlinear_oracle_constraints) + MOI.get(model.model, MOI.ObjectiveSense()) == MOI.FEASIBILITY_SENSE end MOI.supports_incremental_interface(::Optimizer) = true @@ -151,95 +165,38 @@ end MOI.get(::Optimizer, ::MOI.SolverName) = "Ipopt" -function MOI.supports_add_constrained_variable( - ::Optimizer, - ::Type{MOI.Parameter{Float64}}, -) - return true -end +MOI.supports_add_constrained_variable( + model::Optimizer, + S::Type{<:MOI.AbstractScalarSet}, +) = + MOI.supports_add_constrained_variable(model.model, S) -# 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 +function MOI.add_constrained_variable(model::Optimizer, set::MOI.AbstractScalarSet) + model.inner = nothing + x = MOI.add_variable(model) + return x, MOI.add_constraint(model.model, x, set) end function MOI.add_constrained_variable( model::Optimizer, set::MOI.Parameter{Float64}, ) + if model.uses_nlp_block + error("Cannot mix the new and legacy nonlinear APIs") + end model.inner = nothing - _check_no_nlp_block(model) - p, ci = MOI.add_constrained_variable(model.model, set) - return p, ci -end - -function MOI.is_valid( - model::Optimizer, - ci::MOI.ConstraintIndex{MOI.VariableIndex,MOI.Parameter{Float64}}, -) - return MOI.is_valid(model.model, ci) + return MOI.add_constrained_variable(model.model, set) end -function MOI.get( +MOI.supports_constraint( model::Optimizer, - attr::Union{MOI.ListOfConstraintIndices{F,S},MOI.NumberOfConstraints{F,S}}, -) where {F<:MOI.VariableIndex,S<:MOI.Parameter{Float64}} - return MOI.get(model.model, attr) -end + F::Type{<:MOI.AbstractFunction}, + S::Type{<:MOI.AbstractSet}, +) = + MOI.supports_constraint(model.model, F, S) -function MOI.set( - model::Optimizer, - attr::MOI.ConstraintSet, - ci::MOI.ConstraintIndex{MOI.VariableIndex,MOI.Parameter{Float64}}, - set::MOI.Parameter{Float64}, -) - MOI.set(model.model, attr, ci, set) - return -end - -function MOI.supports_constraint( - ::Optimizer, - ::Type{ - <:Union{ - MOI.VariableIndex, - MOI.ScalarAffineFunction{Float64}, - MOI.ScalarQuadraticFunction{Float64}, - MOI.ScalarNonlinearFunction, - }, - }, - ::Type{<:_SETS}, -) - return true -end - -### MOI.ListOfConstraintTypesPresent - -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) - if !((F, S) in ret) - push!(ret, (F, S)) - end - end - return -end - -function MOI.get(model::Optimizer, attr::MOI.ListOfConstraintTypesPresent) - 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.model.qp.parameters) - push!(ret, (MOI.VariableIndex, MOI.Parameter{Float64})) - end - return ret -end +MOI.get(model::Optimizer, attr::MOI.ListOfConstraintTypesPresent) = + MOI.get(model.model, attr) ### MOI.Name @@ -299,13 +256,8 @@ function MOI.get(model::Optimizer, p::MOI.RawOptimizerAttribute) return model.options[p.name] end -### Variables +### Model data forwarding -""" - Ipopt.column(x::MOI.VariableIndex) - -Return the column associated with a variable. -""" Ipopt.column(x::MOI.VariableIndex) = x.value function MOI.add_variable(model::Optimizer) @@ -313,456 +265,52 @@ 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.model) - return x + return MOI.add_variable(model.model) end -function MOI.is_valid(model::Optimizer, x::MOI.VariableIndex) - return MOI.is_valid(model.model, x) -end - -function MOI.get(model::Optimizer, attr::MOI.ListOfVariableIndices) - return MOI.get(model.model, attr) -end - -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.model.variables, ci) -end - -function MOI.get( +MOI.is_valid( model::Optimizer, - attr::Union{ - MOI.NumberOfConstraints{MOI.VariableIndex,<:_SETS}, - MOI.ListOfConstraintIndices{MOI.VariableIndex,<:_SETS}, - }, -) - return MOI.get(model.model.variables, attr) -end - -function MOI.get( - model::Optimizer, - attr::Union{MOI.ConstraintFunction,MOI.ConstraintSet}, - c::MOI.ConstraintIndex{MOI.VariableIndex,<:_SETS}, -) - 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.model.variables, x, set) + index::Union{MOI.VariableIndex,MOI.ConstraintIndex}, +) = MOI.is_valid(model.model, index) +MOI.get(model::Optimizer, attr::MOI.ListOfVariableIndices) = MOI.get(model.model, attr) +MOI.get(model::Optimizer, attr::MOI.NumberOfVariables) = MOI.get(model.model, attr) +MOI.get(model::Optimizer, attr::Union{MOI.NumberOfConstraints,MOI.ListOfConstraintIndices}) = MOI.get(model.model, attr) +MOI.get(model::Optimizer, attr::Union{MOI.ConstraintFunction,MOI.ConstraintSet}, ci::MOI.ConstraintIndex) = MOI.get(model.model, attr, ci) + +function MOI.add_constraint(model::Optimizer, f::MOI.AbstractFunction, s::MOI.AbstractSet) + if model.uses_nlp_block && MOI.Nonlinear._is_nonlinear_input(model.model, f, s) + error("Cannot mix the new and legacy nonlinear APIs") + end model.inner = nothing - return index + return MOI.add_constraint(model.model, f, s) end -function MOI.set( - model::Optimizer, - ::MOI.ConstraintSet, - ci::MOI.ConstraintIndex{MOI.VariableIndex,S}, - set::S, -) where {S<:_SETS} - MOI.set(model.model.variables, MOI.ConstraintSet(), ci, set) +function MOI.set(model::Optimizer, attr::MOI.ConstraintSet, ci::MOI.ConstraintIndex, set) + MOI.set(model.model, attr, ci, set) model.needs_new_inner = true return end -function MOI.delete( - model::Optimizer, - ci::MOI.ConstraintIndex{MOI.VariableIndex,<:_SETS}, -) - MOI.delete(model.model.variables, ci) +function MOI.delete(model::Optimizer, ci::MOI.ConstraintIndex) + MOI.delete(model.model, ci) model.inner = nothing return end -### ScalarAffineFunction and ScalarQuadraticFunction constraints - -function MOI.is_valid( - model::Optimizer, - ci::MOI.ConstraintIndex{F,<:_SETS}, -) where { - F<:Union{ - MOI.ScalarAffineFunction{Float64}, - MOI.ScalarQuadraticFunction{Float64}, - }, -} - return MOI.is_valid(model.model, ci) -end - -function MOI.add_constraint( - model::Optimizer, - func::Union{ - MOI.ScalarAffineFunction{Float64}, - MOI.ScalarQuadraticFunction{Float64}, - }, - set::_SETS, -) - index = MOI.add_constraint(model.model, func, set) - model.inner = nothing - return index +function MOI.supports(model::Optimizer, attr::MOI.ConstraintDualStart, CI::Type{<:MOI.ConstraintIndex}) + return MOI.supports(model.model, attr, CI) end - -function MOI.get( - model::Optimizer, - attr::Union{MOI.NumberOfConstraints{F,S},MOI.ListOfConstraintIndices{F,S}}, -) where { - F<:Union{ - MOI.ScalarAffineFunction{Float64}, - MOI.ScalarQuadraticFunction{Float64}, - }, - S<:_SETS, -} - return MOI.get(model.model, attr) -end - -function MOI.get( - model::Optimizer, - attr::Union{MOI.ConstraintFunction,MOI.ConstraintSet}, - c::MOI.ConstraintIndex{F,<:_SETS}, -) where { - F<:Union{ - MOI.ScalarAffineFunction{Float64}, - MOI.ScalarQuadraticFunction{Float64}, - }, -} - return MOI.get(model.model, attr, c) -end - -function MOI.set( - model::Optimizer, - ::MOI.ConstraintSet, - ci::MOI.ConstraintIndex{F,S}, - set::S, -) where { - F<:Union{ - MOI.ScalarAffineFunction{Float64}, - MOI.ScalarQuadraticFunction{Float64}, - }, - S<:_SETS, -} - MOI.set(model.model, MOI.ConstraintSet(), ci, set) - model.needs_new_inner = true - return -end - -function MOI.supports( - ::Optimizer, - ::MOI.ConstraintDualStart, - ::Type{<:MOI.ConstraintIndex{F,<:_SETS}}, -) where { - F<:Union{ - MOI.ScalarAffineFunction{Float64}, - MOI.ScalarQuadraticFunction{Float64}, - }, -} - return true -end - -function MOI.get( - model::Optimizer, - attr::MOI.ConstraintDualStart, - c::MOI.ConstraintIndex{F,<:_SETS}, -) where { - F<:Union{ - MOI.ScalarAffineFunction{Float64}, - MOI.ScalarQuadraticFunction{Float64}, - }, -} - return MOI.get(model.model, attr, c) -end - -function MOI.set( - model::Optimizer, - attr::MOI.ConstraintDualStart, - ci::MOI.ConstraintIndex{F,<:_SETS}, - value::Union{Real,Nothing}, -) where { - F<:Union{ - MOI.ScalarAffineFunction{Float64}, - MOI.ScalarQuadraticFunction{Float64}, - }, -} - MOI.throw_if_not_valid(model, ci) +MOI.get(model::Optimizer, attr::MOI.ConstraintDualStart, ci::MOI.ConstraintIndex) = MOI.get(model.model, attr, ci) +function MOI.set(model::Optimizer, attr::MOI.ConstraintDualStart, ci::MOI.ConstraintIndex, value) MOI.set(model.model, attr, ci, value) - # No need to reset model.inner, because this gets handled in optimize!. - return -end - -### ScalarNonlinearFunction - -function MOI.is_valid( - model::Optimizer, - ci::MOI.ConstraintIndex{MOI.ScalarNonlinearFunction,<:_SETS}, -) - index = MOI.Nonlinear.ConstraintIndex(ci.value) - return MOI.is_valid(model.model.inner, index) -end - -function MOI.get( - model::Optimizer, - attr::MOI.ListOfConstraintIndices{F,S}, -) where {F<:MOI.ScalarNonlinearFunction,S<:_SETS} - ret = MOI.ConstraintIndex{F,S}[] - for (k, v) in model.model.inner.constraints - if v.set isa S - push!(ret, MOI.ConstraintIndex{F,S}(k.value)) - end - end - return ret -end - -function MOI.get( - model::Optimizer, - attr::MOI.NumberOfConstraints{F,S}, -) where {F<:MOI.ScalarNonlinearFunction,S<:_SETS} - return count(v.set isa S for v in values(model.model.inner.constraints)) -end - -function MOI.add_constraint( - model::Optimizer, - f::MOI.ScalarNonlinearFunction, - s::_SETS, -) - _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 - -function MOI.supports( - ::Optimizer, - ::MOI.ObjectiveFunction{MOI.ScalarNonlinearFunction}, -) - return true -end - -function MOI.set( - model::Optimizer, - attr::MOI.ObjectiveFunction{MOI.ScalarNonlinearFunction}, - func::MOI.ScalarNonlinearFunction, -) - _check_no_nlp_block(model) - MOI.Nonlinear.set_objective(model.model, func) - model.inner = nothing - return -end - -function MOI.get( - model::Optimizer, - ::MOI.ConstraintSet, - ci::MOI.ConstraintIndex{MOI.ScalarNonlinearFunction,<:_SETS}, -) - MOI.throw_if_not_valid(model, ci) - index = MOI.Nonlinear.ConstraintIndex(ci.value) - return model.model.inner[index].set -end - -function MOI.set( - model::Optimizer, - ::MOI.ConstraintSet, - ci::MOI.ConstraintIndex{MOI.ScalarNonlinearFunction,S}, - set::S, -) where {S<:_SETS} - MOI.throw_if_not_valid(model, ci) - index = MOI.Nonlinear.ConstraintIndex(ci.value) - func = model.model.inner[index].expression - model.model.inner.constraints[index] = MOI.Nonlinear.Constraint(func, set) - model.needs_new_inner = true - return -end - -function MOI.supports( - ::Optimizer, - ::MOI.ConstraintDualStart, - ::Type{<:MOI.ConstraintIndex{MOI.ScalarNonlinearFunction,<:_SETS}}, -) - return true -end - -function MOI.get( - model::Optimizer, - attr::MOI.ConstraintDualStart, - ci::MOI.ConstraintIndex{MOI.ScalarNonlinearFunction,<:_SETS}, -) - MOI.throw_if_not_valid(model, ci) - index = MOI.Nonlinear.ConstraintIndex(ci.value) - return get(model.mult_g_nlp, index, nothing) -end - -function MOI.set( - model::Optimizer, - attr::MOI.ConstraintDualStart, - ci::MOI.ConstraintIndex{MOI.ScalarNonlinearFunction,<:_SETS}, - value::Union{Real,Nothing}, -) - MOI.throw_if_not_valid(model, ci) - index = MOI.Nonlinear.ConstraintIndex(ci.value) - if value === nothing - delete!(model.mult_g_nlp, index) - else - model.mult_g_nlp[index] = convert(Float64, value) - end - # No need to reset model.inner, because this gets handled in optimize!. return end -### MOI.VectorOfVariables in MOI.VectorNonlinearOracle{Float64} - -function MOI.supports_constraint( - ::Optimizer, - ::Type{MOI.VectorOfVariables}, - ::Type{MOI.VectorNonlinearOracle{Float64}}, -) - return true -end - -function MOI.is_valid( - model::Optimizer, - ci::MOI.ConstraintIndex{ - MOI.VectorOfVariables, - MOI.VectorNonlinearOracle{Float64}, - }, -) - return 1 <= ci.value <= length(model.vector_nonlinear_oracle_constraints) -end - -function MOI.get( - model::Optimizer, - attr::MOI.ListOfConstraintIndices{F,S}, -) where {F<:MOI.VectorOfVariables,S<:MOI.VectorNonlinearOracle{Float64}} - n = length(model.vector_nonlinear_oracle_constraints) - return MOI.ConstraintIndex{F,S}.(1:n) -end - -function MOI.get( - model::Optimizer, - attr::MOI.NumberOfConstraints{F,S}, -) where {F<:MOI.VectorOfVariables,S<:MOI.VectorNonlinearOracle{Float64}} - return length(model.vector_nonlinear_oracle_constraints) -end - -function MOI.add_constraint( - model::Optimizer, - f::F, - s::S, -) where {F<:MOI.VectorOfVariables,S<:MOI.VectorNonlinearOracle{Float64}} - model.inner = nothing - cache = _VectorNonlinearOracleCache(s) - push!(model.vector_nonlinear_oracle_constraints, (f, cache)) - n = length(model.vector_nonlinear_oracle_constraints) - return MOI.ConstraintIndex{F,S}(n) -end - -function row( - model::Optimizer, - ci::MOI.ConstraintIndex{F,S}, -) where {F<:MOI.VectorOfVariables,S<:MOI.VectorNonlinearOracle{Float64}} - offset = length(model.model) - for i in 1:(ci.value-1) - _, s = model.vector_nonlinear_oracle_constraints[i] - offset += s.set.output_dimension - end - _, s = model.vector_nonlinear_oracle_constraints[ci.value] - return offset .+ (1:s.set.output_dimension) -end - -function MOI.get( - model::Optimizer, - attr::MOI.ConstraintPrimal, - ci::MOI.ConstraintIndex{F,S}, -) where {F<:MOI.VectorOfVariables,S<:MOI.VectorNonlinearOracle{Float64}} - MOI.check_result_index_bounds(model, attr) - MOI.throw_if_not_valid(model, ci) - f, _ = model.vector_nonlinear_oracle_constraints[ci.value] - return MOI.get.(model, MOI.VariablePrimal(attr.result_index), f.variables) -end - -function MOI.get( - model::Optimizer, - attr::MOI.ConstraintDual, - ci::MOI.ConstraintIndex{F,S}, -) where {F<:MOI.VectorOfVariables,S<:MOI.VectorNonlinearOracle{Float64}} - MOI.check_result_index_bounds(model, attr) - MOI.throw_if_not_valid(model, ci) - sign = -_dual_multiplier(model) - f, s = model.vector_nonlinear_oracle_constraints[ci.value] - λ = model.inner.mult_g[row(model, ci)] - J = Tuple{Int,Int}[] - _jacobian_structure(J, 0, f, s) - J_val = zeros(length(J)) - _eval_constraint_jacobian(J_val, 0, model.inner.x, f, s) - dual = zeros(MOI.dimension(s.set)) - # dual = λ' * J(x) - col_to_index = Dict(x.value => j for (j, x) in enumerate(f.variables)) - for ((row, col), J_rc) in zip(J, J_val) - dual[col_to_index[col]] += sign * J_rc * λ[row] - end - return dual -end - -function MOI.get( - model::Optimizer, - attr::MOI.LagrangeMultiplier, - ci::MOI.ConstraintIndex{F,S}, -) where {F<:MOI.VectorOfVariables,S<:MOI.VectorNonlinearOracle{Float64}} - MOI.check_result_index_bounds(model, attr) - MOI.throw_if_not_valid(model, ci) - return -_dual_multiplier(model) * model.inner.mult_g[row(model, ci)] -end - -function MOI.supports( - ::Optimizer, - ::MOI.LagrangeMultiplierStart, - ::Type{MOI.ConstraintIndex{F,S}}, -) where {F<:MOI.VectorOfVariables,S<:MOI.VectorNonlinearOracle{Float64}} - return true -end - -function MOI.get( - model::Optimizer, - attr::MOI.LagrangeMultiplierStart, - ci::MOI.ConstraintIndex{F,S}, -) where {F<:MOI.VectorOfVariables,S<:MOI.VectorNonlinearOracle{Float64}} - _, cache = model.vector_nonlinear_oracle_constraints[ci.value] - return cache.start -end - -function MOI.set( - model::Optimizer, - attr::MOI.LagrangeMultiplierStart, - ci::MOI.ConstraintIndex{F,S}, - start::Union{Nothing,Vector{Float64}}, -) where {F<:MOI.VectorOfVariables,S<:MOI.VectorNonlinearOracle{Float64}} - _, cache = model.vector_nonlinear_oracle_constraints[ci.value] - cache.start = start - return -end - -### UserDefinedFunction - -MOI.supports(model::Optimizer, ::MOI.UserDefinedFunction) = true - -function MOI.set(model::Optimizer, attr::MOI.UserDefinedFunction, args) - _check_no_nlp_block(model) - MOI.Nonlinear.register_operator( - model.model.inner, - attr.name, - attr.arity, - args..., - ) - return -end - -### ListOfSupportedNonlinearOperators - -function MOI.get(model::Optimizer, attr::MOI.ListOfSupportedNonlinearOperators) - return MOI.get(model.model, attr) +MOI.supports(model::Optimizer, attr::MOI.UserDefinedFunction) = MOI.supports(model.model, attr) +function MOI.set(model::Optimizer, attr::MOI.UserDefinedFunction, value) + return MOI.set(model.model, attr, value) end +MOI.get(model::Optimizer, attr::MOI.ListOfSupportedNonlinearOperators) = MOI.get(model.model, attr) ### MOI.VariablePrimalStart @@ -806,7 +354,7 @@ end _dual_start(::Optimizer, ::Nothing, ::Int = 1) = 0.0 function _dual_start(model::Optimizer, value::Real, scale::Int = 1) - return _dual_multiplier(model) * value * scale + return value * scale end function MOI.supports( @@ -916,7 +464,7 @@ 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 !MOI.is_empty(model.model.inner) + if MOI.Nonlinear._has_nonlinear_data(model.model) error("Cannot mix the new and legacy nonlinear APIs") end model.nlp_data = nlp_data @@ -925,314 +473,38 @@ function MOI.set(model::Optimizer, ::MOI.NLPBlock, nlp_data::MOI.NLPBlockData) return end -### ObjectiveSense +### Objective forwarding -MOI.supports(::Optimizer, ::MOI.ObjectiveSense) = true - -function MOI.set( - model::Optimizer, - ::MOI.ObjectiveSense, - sense::MOI.OptimizationSense, -) - model.sense = sense +MOI.supports(model::Optimizer, attr::MOI.ObjectiveSense) = MOI.supports(model.model, attr) +MOI.get(model::Optimizer, attr::MOI.ObjectiveSense) = MOI.get(model.model, attr) +function MOI.set(model::Optimizer, attr::MOI.ObjectiveSense, sense::MOI.OptimizationSense) + MOI.set(model.model, attr, sense) model.needs_new_inner = true return end -MOI.get(model::Optimizer, ::MOI.ObjectiveSense) = model.sense - -### ObjectiveFunction - -function MOI.get(model::Optimizer, attr::MOI.ObjectiveFunctionType) - if model.model.inner.objective !== nothing - return MOI.ScalarNonlinearFunction +MOI.get(model::Optimizer, attr::MOI.ObjectiveFunctionType) = MOI.get(model.model, attr) +MOI.supports(model::Optimizer, attr::MOI.ObjectiveFunction) = MOI.supports(model.model, attr) +MOI.get(model::Optimizer, attr::MOI.ObjectiveFunction) = MOI.get(model.model, attr) +function MOI.set(model::Optimizer, attr::MOI.ObjectiveFunction, f) + if model.uses_nlp_block && + MOI.Nonlinear._is_nonlinear_objective(model.model, f) + error("Cannot mix the new and legacy nonlinear APIs") end - return MOI.get(model.model, attr) -end - -function MOI.supports( - ::Optimizer, - ::MOI.ObjectiveFunction{ - <:Union{ - MOI.VariableIndex, - MOI.ScalarAffineFunction{Float64}, - MOI.ScalarQuadraticFunction{Float64}, - }, - }, -) - return true -end - -function MOI.get( - model::Optimizer, - attr::MOI.ObjectiveFunction{F}, -) where { - F<:Union{ - MOI.VariableIndex, - MOI.ScalarAffineFunction{Float64}, - MOI.ScalarQuadraticFunction{Float64}, - }, -} - return convert(F, MOI.get(model.model, attr)) -end - -function MOI.set( - model::Optimizer, - attr::MOI.ObjectiveFunction{F}, - func::F, -) where { - F<:Union{ - MOI.VariableIndex, - MOI.ScalarAffineFunction{Float64}, - MOI.ScalarQuadraticFunction{Float64}, - }, -} - # This also clears any objective of the inner nonlinear model. - MOI.Nonlinear.set_objective(model.model, func) + MOI.set(model.model, attr, f) model.inner = nothing return end -### _OracleNLPEvaluator - -""" - _OracleNLPEvaluator(model::Optimizer) +### Evaluator forwarding -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) - # TODO(odow): FEASIBILITY_SENSE could produce confusing solver output if - # a nonzero objective is set. - if model.sense == MOI.FEASIBILITY_SENSE - return 0.0 - elseif model.nlp_data.has_objective - return MOI.eval_objective(model.nlp_data.evaluator, x)::Float64 - end - return MOI.eval_objective(model.evaluator, x) -end - -### Eval_Grad_F_CB - -function MOI.eval_objective_gradient(model::Optimizer, grad, x) - if model.sense == MOI.FEASIBILITY_SENSE - grad .= zero(eltype(grad)) - elseif model.nlp_data.has_objective - MOI.eval_objective_gradient(model.nlp_data.evaluator, grad, x) - else - MOI.eval_objective_gradient(model.evaluator, grad, x) - end - return -end - -### Eval_G_CB - -function _eval_constraint( - g::AbstractVector, - offset::Int, - x::AbstractVector, - f::MOI.VectorOfVariables, - s::_VectorNonlinearOracleCache, -) - for i in 1:s.set.input_dimension - s.x[i] = x[f.variables[i].value] - end - ret = view(g, offset .+ (1:s.set.output_dimension)) - s.eval_f_timer += @elapsed s.set.eval_f(ret, s.x) - return offset + s.set.output_dimension -end - -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 - 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( - ret::AbstractVector, - row_offset::Int, - f::MOI.VectorOfVariables, - s::_VectorNonlinearOracleCache, -) - for (i, j) in s.set.jacobian_structure - push!(ret, (row_offset + i, f.variables[j].value)) - end - return row_offset + s.set.output_dimension -end - -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(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 - end - return J -end - -function MOI.jacobian_structure(model::Optimizer) - return MOI.jacobian_structure(model.evaluator) -end - -function _eval_constraint_jacobian( - values::AbstractVector, - offset::Int, - x::AbstractVector, - f::MOI.VectorOfVariables, - s::_VectorNonlinearOracleCache, -) - for i in 1:s.set.input_dimension - s.x[i] = x[f.variables[i].value] - end - nnz = length(s.set.jacobian_structure) - s.eval_jacobian_timer += - @elapsed s.set.eval_jacobian(view(values, offset .+ (1:nnz)), s.x) - return offset + nnz -end - -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(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( - ret::AbstractVector, - f::MOI.VectorOfVariables, - s::_VectorNonlinearOracleCache, -) - for (i, j) in s.set.hessian_lagrangian_structure - push!(ret, (f.variables[i].value, f.variables[j].value)) - end - return -end - -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(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, - x::AbstractVector, - μ::AbstractVector, - μ_offset::Int, - f::MOI.VectorOfVariables, - s::_VectorNonlinearOracleCache, -) - for i in 1:s.set.input_dimension - s.x[i] = x[f.variables[i].value] - end - H_nnz = length(s.set.hessian_lagrangian_structure) - H_view = view(H, H_offset .+ (1:H_nnz)) - μ_view = view(μ, μ_offset .+ (1:s.set.output_dimension)) - s.eval_hessian_lagrangian_timer += - @elapsed s.set.eval_hessian_lagrangian(H_view, s.x, μ_view) - return H_offset + H_nnz, μ_offset + s.set.output_dimension -end - -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(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.eval_objective(model::Optimizer, x) = MOI.eval_objective(model.evaluator, x) +MOI.eval_objective_gradient(model::Optimizer, g, x) = MOI.eval_objective_gradient(model.evaluator, g, x) +MOI.eval_constraint(model::Optimizer, g, x) = MOI.eval_constraint(model.evaluator, g, x) +MOI.jacobian_structure(model::Optimizer) = MOI.jacobian_structure(model.evaluator) +MOI.eval_constraint_jacobian(model::Optimizer, J, x) = MOI.eval_constraint_jacobian(model.evaluator, J, x) +MOI.hessian_lagrangian_structure(model::Optimizer) = MOI.hessian_lagrangian_structure(model.evaluator) +MOI.eval_hessian_lagrangian(model::Optimizer, H, x, sigma, mu) = MOI.eval_hessian_lagrangian(model.evaluator, H, x, sigma, mu) ### MOI.AutomaticDifferentiationBackend @@ -1290,10 +562,11 @@ function _setup_inner(model::Optimizer)::Ipopt.IpoptProblem return _eval_h_cb(model, x, rows, cols, obj_factor, lambda, values) end has_hessian = model.hessian_sparsity !== nothing + x_L, x_U = MOI.Nonlinear._variable_bounds(model.model) model.inner = Ipopt.CreateIpoptProblem( - length(model.model.variables.lower), - model.model.variables.lower, - model.model.variables.upper, + length(x_L), + x_L, + x_U, length(g_L), g_L, g_U, @@ -1307,11 +580,6 @@ function _setup_inner(model::Optimizer)::Ipopt.IpoptProblem has_hessian ? eval_h_cb : nothing, ) inner = model.inner::Ipopt.IpoptProblem - if model.sense == MOI.MIN_SENSE - Ipopt.AddIpoptNumOption(inner, "obj_scaling_factor", 1.0) - elseif model.sense == MOI.MAX_SENSE - Ipopt.AddIpoptNumOption(inner, "obj_scaling_factor", -1.0) - end # Ipopt crashes by default if NaN/Inf values are returned from the # evaluation callbacks. This option tells Ipopt to explicitly check for them # and return Invalid_Number_Detected instead. This setting may result in a @@ -1351,30 +619,29 @@ function _setup_model(model::Optimizer) model.invalid_model = true return end - # 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.model.inner, model.ad_backend, vars), + vars = MOI.get(model.model, MOI.ListOfVariableIndices()) + if model.uses_nlp_block + oracles = model.model.inner + inner = MOI.Nonlinear.EvaluatorWithOracles( + oracles, + _NLPBlockEvaluator( + model.nlp_data, + MOI.get(model.model, MOI.ObjectiveSense()), + ), + vars, ) + model.evaluator = MOI.Nonlinear.EvaluatorWithQuad(model.model, inner) + else + model.evaluator = + MOI.Nonlinear.Evaluator(model.model, model.ad_backend, vars) end - 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.evaluator) + has_constraints = !isempty(MOI.Nonlinear._constraint_bounds(model.evaluator)) init_feat = [:Grad] if has_hessian push!(init_feat, :Hess) end - if has_nlp_constraints + if has_constraints push!(init_feat, :Jac) end MOI.initialize(model.evaluator, init_feat) @@ -1383,8 +650,7 @@ function _setup_model(model::Optimizer) if has_hessian model.hessian_sparsity = MOI.hessian_lagrangian_structure(model) end - model.has_only_linear_constraints = - !has_nlp_constraints && !has_quadratic_constraints + model.has_only_linear_constraints = false model.needs_new_inner = true return end @@ -1418,37 +684,22 @@ function MOI.optimize!(model::Optimizer) end # Initialize the starting point, projecting variables from 0 onto their # bounds if VariablePrimalStart is not provided. + x_L, x_U = MOI.Nonlinear._variable_bounds(model.model) for i in 1:length(model.variable_primal_start) inner.x[i] = something( model.variable_primal_start[i], - clamp( - 0.0, - model.model.variables.lower[i], - model.model.variables.upper[i], - ), + clamp(0.0, x_L[i], x_U[i]), ) end - for (i, start) in enumerate(model.model.qp.mult_g) - inner.mult_g[i] = _dual_start(model, start, -1) - end - 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... - for (_, cache) in model.vector_nonlinear_oracle_constraints - if cache.start !== nothing - for i in 1:cache.set.output_dimension - inner.mult_g[offset+i] = - _dual_start(model, cache.start[i], -1) - end - end - offset += cache.set.output_dimension - end - # then come the ScalarNonlinearFunctions.... - for (key, val) in model.mult_g_nlp - inner.mult_g[offset+key.value] = _dual_start(model, val, -1) + inner.mult_g .= 0.0 + starts = MOI.Nonlinear.constraint_dual_starts(model.model) + for (i, start) in enumerate(starts) + if start !== nothing + inner.mult_g[i] = _dual_start(model, start, -1) end - else + end + if model.uses_nlp_block && model.nlp_dual_start !== nothing + offset = length(starts) for (i, start) in enumerate(model.nlp_dual_start::Vector{Float64}) inner.mult_g[offset+i] = _dual_start(model, start, -1) end @@ -1457,13 +708,7 @@ function MOI.optimize!(model::Optimizer) inner.mult_x_L[i] = _dual_start(model, model.mult_x_L[i]) inner.mult_x_U[i] = _dual_start(model, model.mult_x_U[i], -1) end - # Reset timers model.barrier_iterations = 0 - for (_, s) in model.vector_nonlinear_oracle_constraints - s.eval_f_timer = 0.0 - s.eval_jacobian_timer = 0.0 - s.eval_hessian_lagrangian_timer = 0.0 - end Ipopt.IpoptSolve(inner) model.solve_time = time() - start_time return @@ -1530,7 +775,7 @@ end function _manually_evaluated_primal_status(model::Optimizer) x, g = model.inner.x, model.inner.g - x_L, x_U = model.model.variables.lower, model.model.variables.upper + x_L, x_U = MOI.Nonlinear._variable_bounds(model.model) 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] @@ -1585,7 +830,7 @@ MOI.get(model::Optimizer, ::MOI.BarrierIterations) = model.barrier_iterations function MOI.get(model::Optimizer, attr::MOI.ObjectiveValue) MOI.check_result_index_bounds(model, attr) - return model.inner.obj_val + return _dual_multiplier(model) * model.inner.obj_val end ### MOI.VariablePrimal @@ -1608,27 +853,19 @@ end ### MOI.ConstraintPrimal -function row( - model::Optimizer, - ci::MOI.ConstraintIndex{F}, -) where { - F<:Union{ - MOI.ScalarAffineFunction{Float64}, - MOI.ScalarQuadraticFunction{Float64}, - }, -} - return ci.value +function row(model::Optimizer, ci::MOI.ConstraintIndex) + return only(MOI.Nonlinear.constraint_rows(model.model, ci)) end -function row( +function MOI.get( model::Optimizer, - ci::MOI.ConstraintIndex{MOI.ScalarNonlinearFunction}, + attr::MOI.ConstraintPrimal, + ci::MOI.ConstraintIndex{MOI.VectorOfVariables}, ) - offset = length(model.model) - for (_, s) in model.vector_nonlinear_oracle_constraints - offset += s.set.output_dimension - end - return offset + ci.value + MOI.check_result_index_bounds(model, attr) + MOI.throw_if_not_valid(model, ci) + f = MOI.get(model.model, MOI.ConstraintFunction(), ci) + return MOI.get.(model, MOI.VariablePrimal(attr.result_index), f.variables) end function MOI.get( @@ -1659,7 +896,58 @@ end ### MOI.ConstraintDual -_dual_multiplier(model::Optimizer) = model.sense == MOI.MIN_SENSE ? 1.0 : -1.0 +_dual_multiplier(model::Optimizer) = MOI.get(model.model, MOI.ObjectiveSense()) == MOI.MIN_SENSE ? 1.0 : -1.0 + +function MOI.get( + model::Optimizer, + attr::MOI.LagrangeMultiplier, + ci::MOI.ConstraintIndex, +) + MOI.check_result_index_bounds(model, attr) + MOI.throw_if_not_valid(model, ci) + rows = MOI.Nonlinear.constraint_rows(model.model, ci) + return -model.inner.mult_g[rows] +end + +function MOI.supports( + model::Optimizer, + attr::MOI.LagrangeMultiplierStart, + CI::Type{<:MOI.ConstraintIndex}, +) + return MOI.supports(model.model, attr, CI) +end +MOI.get(model::Optimizer, attr::MOI.LagrangeMultiplierStart, ci::MOI.ConstraintIndex) = + MOI.get(model.model, attr, ci) +function MOI.set( + model::Optimizer, + attr::MOI.LagrangeMultiplierStart, + ci::MOI.ConstraintIndex, + value, +) + return MOI.set(model.model, attr, ci, value) +end + +function MOI.get( + model::Optimizer, + attr::MOI.ConstraintDual, + ci::MOI.ConstraintIndex{MOI.VectorOfVariables}, +) + MOI.check_result_index_bounds(model, attr) + MOI.throw_if_not_valid(model, ci) + rows = Set(MOI.Nonlinear.constraint_rows(model.model, ci)) + structure = MOI.jacobian_structure(model.evaluator) + values = zeros(length(structure)) + MOI.eval_constraint_jacobian(model.evaluator, values, model.inner.x) + dual = zeros(MOI.get(model, MOI.NumberOfVariables())) + sign = -1.0 + for ((r, c), value) in zip(structure, values) + if r in rows + dual[c] += sign * value * model.inner.mult_g[r] + end + end + f = MOI.get(model.model, MOI.ConstraintFunction(), ci) + return dual[getfield.(f.variables, :value)] +end function MOI.get( model::Optimizer, @@ -1674,8 +962,7 @@ function MOI.get( } MOI.check_result_index_bounds(model, attr) MOI.throw_if_not_valid(model, ci) - s = -_dual_multiplier(model) - return s * model.inner.mult_g[row(model, ci)] + return -model.inner.mult_g[row(model, ci)] end function MOI.get( @@ -1686,7 +973,7 @@ function MOI.get( MOI.check_result_index_bounds(model, attr) MOI.throw_if_not_valid(model, ci) rc = model.inner.mult_x_L[ci.value] - model.inner.mult_x_U[ci.value] - return min(0.0, _dual_multiplier(model) * rc) + return min(0.0, rc) end function MOI.get( @@ -1697,7 +984,7 @@ function MOI.get( MOI.check_result_index_bounds(model, attr) MOI.throw_if_not_valid(model, ci) rc = model.inner.mult_x_L[ci.value] - model.inner.mult_x_U[ci.value] - return max(0.0, _dual_multiplier(model) * rc) + return max(0.0, rc) end function MOI.get( @@ -1708,7 +995,7 @@ function MOI.get( MOI.check_result_index_bounds(model, attr) MOI.throw_if_not_valid(model, ci) rc = model.inner.mult_x_L[ci.value] - model.inner.mult_x_U[ci.value] - return _dual_multiplier(model) * rc + return rc end function MOI.get( @@ -1719,15 +1006,14 @@ function MOI.get( MOI.check_result_index_bounds(model, attr) MOI.throw_if_not_valid(model, ci) rc = model.inner.mult_x_L[ci.value] - model.inner.mult_x_U[ci.value] - return _dual_multiplier(model) * rc + return rc end ### MOI.NLPBlockDual 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.model)+1):end] + return -model.inner.mult_g[(length(model.inner.mult_g) - length(model.nlp_data.constraint_bounds) + 1):end] end ### Ipopt.CallbackFunction diff --git a/test/MOI_wrapper.jl b/test/MOI_wrapper.jl index 8894692..1854669 100644 --- a/test/MOI_wrapper.jl +++ b/test/MOI_wrapper.jl @@ -933,22 +933,6 @@ function test_vector_nonlinear_oracle() @test isapprox(y_v, [x_v[1]^2, x_v[2]^2 + x_v[3]^3], atol = 1e-5) @test MOI.get(model, MOI.ConstraintPrimal(), c) ≈ [x_v; y_v] @test MOI.get(model, MOI.ConstraintDual(), c) ≈ zeros(5) - # Test timers with plenty of buffer to avoid a flakey test - for (_, cache) in model.vector_nonlinear_oracle_constraints - @show cache.eval_f_timer - @test 0.9 < cache.eval_f_timer < 2 - @test 0.9 < cache.eval_jacobian_timer < 4 - @test 0.9 < cache.eval_hessian_lagrangian_timer < 2 - end - # Test that optimize! resets the timers. Upper bounds are chosen such that - # they're violated if times from both solves were added together. - MOI.optimize!(model) - for (_, cache) in model.vector_nonlinear_oracle_constraints - @show cache.eval_f_timer - @test 0.9 < cache.eval_f_timer < 2 - @test 0.9 < cache.eval_jacobian_timer < 4 - @test 0.9 < cache.eval_hessian_lagrangian_timer < 2 - end MOI.set(model, MOI.RawOptimizerAttribute("max_iter"), 0) MOI.optimize!(model) @test MOI.get(model, MOI.PrimalStatus()) == MOI.INFEASIBLE_POINT @@ -1219,9 +1203,9 @@ function test_issue_491() g = [MOI.ScalarNonlinearFunction(:log, Any[x[i]]) for i in 1:2] c = MOI.add_constraint.(model, g, MOI.LessThan(1.0)) MOI.set.(model, MOI.ConstraintDualStart(), c, 0.5) - @test length(model.mult_g_nlp) == 2 + @test MOI.get.(model, MOI.ConstraintDualStart(), c) == [0.5, 0.5] MOI.empty!(model) - @test isempty(model.mult_g_nlp) + @test MOI.is_empty(model) return end From 7e6eff7d658e474b7ded4ea695e6caeb1e115f4d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Beno=C3=AEt=20Legat?= Date: Sun, 6 Sep 2026 15:29:39 +0200 Subject: [PATCH 7/7] Use MOI.Nonlinear.model --- ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl | 31 +++++++++++++-------- 1 file changed, 19 insertions(+), 12 deletions(-) diff --git a/ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl b/ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl index 5e3555a..1f67485 100644 --- a/ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl +++ b/ext/IpoptMathOptInterfaceExt/MOI_wrapper.jl @@ -15,10 +15,7 @@ mutable struct Optimizer <: MOI.AbstractOptimizer silent::Bool options::Dict{String,Any} solve_time::Float64 - model::MOI.Nonlinear.ModelWithQuad{ - Float64, - MOI.Nonlinear.ModelWithOracles{Float64,MOI.Nonlinear.Model}, - } + model::MOI.ModelLike variable_primal_start::Vector{Union{Nothing,Float64}} mult_x_L::Vector{Union{Nothing,Float64}} mult_x_U::Vector{Union{Nothing,Float64}} @@ -38,6 +35,7 @@ mutable struct Optimizer <: MOI.AbstractOptimizer has_only_linear_constraints::Bool function Optimizer() + backend = MOI.Nonlinear.SparseReverseMode() return new( nothing, "", @@ -45,9 +43,7 @@ mutable struct Optimizer <: MOI.AbstractOptimizer false, Dict{String,Any}(), NaN, - MOI.Nonlinear.ModelWithQuad( - MOI.Nonlinear.ModelWithOracles(MOI.Nonlinear.Model()), - ), + MOI.Nonlinear.model(backend), Union{Nothing,Float64}[], Union{Nothing,Float64}[], Union{Nothing,Float64}[], @@ -57,7 +53,7 @@ mutable struct Optimizer <: MOI.AbstractOptimizer nothing, nothing, 0, - MOI.Nonlinear.SparseReverseMode(), + backend, Tuple{Int,Int}[], nothing, true, @@ -127,9 +123,7 @@ function MOI.empty!(model::Optimizer) # SKIP: model.silent # SKIP: model.options model.solve_time = 0.0 - model.model = MOI.Nonlinear.ModelWithQuad( - MOI.Nonlinear.ModelWithOracles(MOI.Nonlinear.Model()), - ) + model.model = MOI.Nonlinear.model(model.ad_backend) empty!(model.variable_primal_start) empty!(model.mult_x_L) empty!(model.mult_x_U) @@ -149,7 +143,6 @@ end function MOI.is_empty(model::Optimizer) return MOI.get(model.model, MOI.NumberOfVariables()) == 0 && - isempty(MOI.get(model.model, MOI.ListOfConstraintTypesPresent())) && isempty(model.variable_primal_start) && isempty(model.mult_x_L) && isempty(model.mult_x_U) && @@ -523,6 +516,14 @@ function MOI.set( # don't requrire == for `::MOI.Nonlinear.AutomaticDifferentiationBackend` so # act defensive and invalidate regardless. model.inner = nothing + if MOI.get(model.model, MOI.NumberOfVariables()) != 0 || + MOI.get(model.model, MOI.ObjectiveSense()) != MOI.FEASIBILITY_SENSE + error( + "The automatic-differentiation backend must be set before " * + "adding model data.", + ) + end + model.model = MOI.Nonlinear.model(backend) model.ad_backend = backend return end @@ -621,6 +622,12 @@ function _setup_model(model::Optimizer) end vars = MOI.get(model.model, MOI.ListOfVariableIndices()) if model.uses_nlp_block + if !(model.model isa MOI.Nonlinear.ModelWithQuad) + error( + "The legacy `MOI.NLPBlock` interface cannot be combined " * + "with the selected automatic-differentiation backend.", + ) + end oracles = model.model.inner inner = MOI.Nonlinear.EvaluatorWithOracles( oracles,