AbstractCondensedKKTSystem{T, VT, MT} <: AbstractKKTSystem{T, VT, MT}

The condensed KKT system simplifies further the AbstractReducedKKTSystem by removing the rows associated to the slack variables $s$ and the inequalities.

At the primal-dual iterate $(x, y)$, the matrix writes

[Wₓₓ + Σₓ + Aᵢ' Σₛ Aᵢ    Aₑ']  [Δx]
[         Aₑ              0 ]  [Δy]

with

• $Wₓₓ$: Hessian of the Lagrangian.
• $Aₑ$: Jacobian of the equality constraints
• $Aᵢ$: Jacobian of the inequality constraints
• $Σₓ = X⁻¹ V$
• $Σₛ = S⁻¹ W$

AbstractKKTSystem{T, VT<:AbstractVector{T}, MT<:AbstractMatrix{T}}

Abstract type for KKT system.

AbstractKKTVector{T, VT}

Supertype for KKT's right-hand-side vectors $(x, s, y, z, ν, w)$.

AbstractLinearSolver

Abstract type for linear solver targeting the resolution of the linear system $Ax=b$.

AbstractReducedKKTSystem{T, VT, MT} <: AbstractKKTSystem{T, VT, MT}

The reduced KKT system is a simplification of the original Augmented KKT system. Comparing to AbstractUnreducedKKTSystem), AbstractReducedKKTSystem removes the two last rows associated to the bounds' duals $(ν, w)$.

At a primal-dual iterate $(x, s, y, z)$, the matrix writes

[Wₓₓ + Σₓ   0    Aₑ'   Aᵢ']  [Δx]
[ 0         Σₛ    0    -I ]  [Δs]
[Aₑ         0     0     0 ]  [Δy]
[Aᵢ        -I     0     0 ]  [Δz]

with

• $Wₓₓ$: Hessian of the Lagrangian.
• $Aₑ$: Jacobian of the equality constraints
• $Aᵢ$: Jacobian of the inequality constraints
• $Σₓ = X⁻¹ V$
• $Σₛ = S⁻¹ W$

AbstractUnreducedKKTSystem{T, VT, MT} <: AbstractKKTSystem{T, VT, MT}

Augmented KKT system associated to the linearization of the KKT conditions at the current primal-dual iterate $(x, s, y, z, ν, w)$.

The associated matrix is

[Wₓₓ  0  Aₑ'  Aᵢ'  -I   0 ]  [Δx]
[ 0   0   0   -I    0  -I ]  [Δs]
[Aₑ   0   0    0    0   0 ]  [Δy]
[Aᵢ  -I   0    0    0   0 ]  [Δz]
[V    0   0    0    X   0 ]  [Δν]
[0    W   0    0    0   S ]  [Δw]

with

• $Wₓₓ$: Hessian of the Lagrangian.
• $Aₑ$: Jacobian of the equality constraints
• $Aᵢ$: Jacobian of the inequality constraints
• $X = diag(x)$
• $S = diag(s)$
• $V = diag(ν)$
• $W = diag(w)$

DenseCondensedKKTSystem{T, VT, MT} <: AbstractCondensedKKTSystem{T, VT, MT}

Implement AbstractCondensedKKTSystem with dense matrices.

Requires a dense linear solver to factorize the associated KKT system (otherwise an error is returned).

DenseKKTSystem{T, VT, MT} <: AbstractReducedKKTSystem{T, VT, MT}

Implement AbstractReducedKKTSystem with dense matrices.

Requires a dense linear solver to be factorized (otherwise an error is returned).

ReducedKKTVector{T, VT<:AbstractVector{T}} <: AbstractKKTVector{T, VT}

KKT vector $(x, s, y, z)$, associated to a AbstractReducedKKTSystem.

Compared to UnreducedKKTVector, it does not store the dual values associated to the primal's lower and upper bounds.

SparseKKTSystem{T, VT, MT} <: AbstractReducedKKTSystem{T, VT, MT}

Implement the AbstractReducedKKTSystem in sparse COO format.

SparseUnreducedKKTSystem{T, VT, MT} <: AbstractUnreducedKKTSystem{T, VT, MT}

Implement the AbstractUnreducedKKTSystem in sparse COO format.

UnreducedKKTVector{T, VT<:AbstractVector{T}} <: AbstractKKTVector{T, VT}

Full KKT vector $(x, s, y, z, ν, w)$, associated to a AbstractUnreducedKKTSystem.

build_kkt!(kkt::AbstractKKTSystem)

Assemble the KKT matrix before calling the factorization routine.

compress_hessian!(kkt::AbstractKKTSystem)

Compress the Hessian inside kkt's internals. This function is called every time a new Hessian is evaluated.

Default implementation do nothing.

compress_jacobian!(kkt::AbstractKKTSystem)

Compress the Jacobian inside kkt's internals. This function is called every time a new Jacobian is evaluated.

By default, the function updates in the Jacobian the coefficients associated to the slack variables.

dual(X::AbstractKKTVector)

Return the dual values $(y, z)$ stored in the KKT vector X.

dual_lb(X::AbstractKKTVector)

Return the dual values $ν$ associated to the lower-bound stored in the KKT vector X.

dual_ub(X::AbstractKKTVector)

Return the dual values $w$ associated to the upper-bound stored in the KKT vector X.

factorize!(::AbstractLinearSolver)

Factorize the matrix $A$ and updates the factors inside the AbstractLinearSolver instance.

full(X::AbstractKKTVector)

Return the all the values stored inside the KKT vector X.

Get Hessian matrix

Get Jacobian matrix

get_kkt(kkt::AbstractKKTSystem)::AbstractMatrix

Return a pointer to the KKT matrix implemented in kkt. The pointer is passed afterward to a linear solver.

Dense Hessian callback

inertia(::AbstractLinearSolver)

Return the inertia (n, m, p) of the linear system as a tuple.

Note

The inertia is defined as a tuple $(n, m, p)$, with

• $n$: number of positive eigenvalues
• $m$: number of negative eigenvalues
• $p$: number of zero eigenvalues

initialize!(kkt::AbstractKKTSystem)

Initialize KKT system with default values. Called when we initialize the MadNLPSolver storing the current KKT system kkt.

introduce(::AbstractLinearSolver)

Print the name of the linear solver.

is_inertia(::AbstractLinearSolver)

Return true if the linear solver supports the computation of the inertia of the linear system.

is_inertia_correct(kkt::AbstractKKTSystem, n::Int, m::Int, p::Int)

Check if the inertia $(n, m, p)$ returned by the linear solver is adapted to the KKT system implemented in kkt.

Return true if KKT system is reduced.

is_supported(solver,T)

Return true if solver supports the floating point number type T.

Examples

julia> is_supported(UmfpackSolver,Float64)
true

julia> is_supported(UmfpackSolver,Float32)
false

Dense Jacobian callback

jtprod!(y::AbstractVector, kkt::AbstractKKTSystem, x::AbstractVector)

Multiply with transpose of Jacobian and store the result in y, such that $y = A' x$ (with $A$ current Jacobian).

Nonzero in Jacobian

Number of primal variables associated to the KKT system.

number_dual(X::AbstractKKTVector)

Get total number of dual values $(y, z)$ in KKT vector X.

number_primal(X::AbstractKKTVector)

Get total number of primal values $(x, s)$ in KKT vector X.

primal(X::AbstractKKTVector)

Return the primal values $(x, s)$ stored in the KKT vector X.

primal_dual(X::AbstractKKTVector)

Return both the primal and the dual values $(x, s, y, z)$ stored in the KKT vector X.

regularize_diagonal!(kkt::AbstractKKTSystem, primal_values::AbstractVector, dual_values::AbstractVector)

Regularize the values in the diagonal of the KKT system. Called internally inside the interior-point routine.

scale_constraints!(
    nlp::AbstractNLPModel,
    con_scale::AbstractVector,
    jac::AbstractMatrix;
    max_gradient=1e-8,
)

Compute the scaling of the constraints associated to the nonlinear model nlp. By default, Ipopt's scaling is applied. The user can write its own function to scale appropriately any custom AbstractNLPModel.

Notes

This function assumes that the Jacobian jac has been evaluated before calling this function.

scale_objective(
    nlp::AbstractNLPModel,
    grad::AbstractVector;
    max_gradient=1e-8,
)

Compute the scaling of the objective associated to the nonlinear model nlp. By default, Ipopt's scaling is applied. The user can write its own function to scale appropriately the objective of any custom AbstractNLPModel.

Notes

This function assumes that the gradient gradient has been evaluated before calling this function.

set_jacobian_scaling!(kkt::AbstractKKTSystem, scaling::AbstractVector)

Set the scaling of the Jacobian with the vector scaling storing the scaling for all the constraints in the problem.

solve!(::AbstractLinearSolver, x::AbstractVector)

Solve the linear system $Ax = b$.

This function assumes the linear system has been factorized previously with factorize!.

solve_refine!(x, ::AbstractIterator, b)

Solve the linear system $Ax = b$ using iterative refinement. The object AbstractIterator stores an instance of a AbstractLinearSolver for the backsolve operations.

Notes

This function assumes the matrix stored in the linear solver has been factorized previously.

timing_callbacks(ips::InteriorPointSolver; ntrials=10)

Return the average timings spent in each callback for ntrials different trials. Results are returned inside a named-tuple.

timing_linear_solver(ips::InteriorPointSolver; ntrials=10)

Return the average timings spent in the linear solver for ntrials different trials. Results are returned inside a named-tuple.

timing_madnlp(ips::InteriorPointSolver; ntrials=10)

Return the average time spent in the callbacks and in the linear solver, for ntrials different trials.

Results are returned as a named-tuple.