Reference

AbstractNLPModel

Base type for an optimization model.

AbstractNLPModelMeta

Base type for metadata related to an optimization model.

AbstractNLSModel <: AbstractNLPModel

Base type for a nonlinear least-squares model.

Counters

Struct for storing the number of function evaluations.

Counters()

Creates an empty Counters struct.

DimensionError <: Exception
DimensionError(name, dim_expected, dim_found)

Error for unexpected dimension. Output: "DimensionError: Input name should have length dim_expected not dim_found"

NLPModelMeta <: AbstractNLPModelMeta

A composite type that represents the main features of the optimization problem

optimize    obj(x)
subject to  lvar ≤    x    ≤ uvar
            lcon ≤ cons(x) ≤ ucon

where x is an nvar-dimensional vector, obj is the real-valued objective function, cons is the vector-valued constraint function, optimize is either "minimize" or "maximize".

Here, lvar, uvar, lcon and ucon are vectors. Some of their components may be infinite to indicate that the corresponding bound or general constraint is not present.

NLPModelMeta(nvar::Integer; kwargs...)
NLPModelMeta(meta::AbstractNLPModelMeta; kwargs...)

Create an NLPModelMeta with nvar variables. Alternatively, create an NLPModelMeta copy from another AbstractNLPModelMeta. The following keyword arguments are accepted:

• x0: initial guess
• lvar: vector of lower bounds
• uvar: vector of upper bounds
• nlvb: number of nonlinear variables in both objectives and constraints
• nlvo: number of nonlinear variables in objectives (includes nlvb)
• nlvc: number of nonlinear variables in constraints (includes nlvb)
• ncon: number of general constraints
• y0: initial Lagrange multipliers
• lcon: vector of constraint lower bounds
• ucon: vector of constraint upper bounds
• nnzo: number of nonzeros in the gradient
• nnzj: number of elements needed to store the nonzeros in the sparse Jacobian
• lin_nnzj: number of elements needed to store the nonzeros in the sparse Jacobian of linear constraints
• nln_nnzj: number of elements needed to store the nonzeros in the sparse Jacobian of nonlinear constraints
• nnzh: number of elements needed to store the nonzeros in the sparse Hessian
• lin: indices of linear constraints
• minimize: true if optimize == minimize
• islp: true if the problem is a linear program
• name: problem name

NLPModelMeta also contains the following attributes, which are computed from the variables above:

• nvar: number of variables
• ifix: indices of fixed variables
• ilow: indices of variables with lower bound only
• iupp: indices of variables with upper bound only
• irng: indices of variables with lower and upper bound (range)
• ifree: indices of free variables
• iinf: indices of visibly infeasible bounds
• jfix: indices of equality constraints
• jlow: indices of constraints of the form c(x) ≥ cl
• jupp: indices of constraints of the form c(x) ≤ cu
• jrng: indices of constraints of the form cl ≤ c(x) ≤ cu
• jfree: indices of "free" constraints (there shouldn't be any)
• jinf: indices of the visibly infeasible constraints
• nlin: number of linear constraints
• nnln: number of nonlinear general constraints
• nln: indices of nonlinear constraints

NLSCounters

Struct for storing the number of functions evaluations for nonlinear least-squares models. NLSCounters also stores a Counters instance named counters.

NLSCounters()

Creates an empty NLSCounters struct.

NLSMeta

Base type for metadata related to a nonlinear least-squares model.

NLSMeta(nequ, nvar; kwargs...)

Create a NLSMeta with nequ equations and nvar variables. The following keyword arguments are accepted:

• x0: initial guess
• nnzj: number of elements needed to store the nonzeros of the Jacobian of the residual
• nnzh: number of elements needed to store the nonzeros of the sum of Hessians of the residuals
• lin: indices of linear residuals

NLSMeta also contains the following attributes, which are computed from the variables above:

• nequ: size of the residual
• nvar: number of variables
• nln: indices of nonlinear residuals
• nnln: number of nonlinear general residuals
• nlin: number of linear residuals

reset!(nlp)

Reset evaluation count and model data (if appropriate) in nlp.

reset!(counters)

Reset evaluation counters

bound_constrained(nlp)
bound_constrained(meta)

Returns whether the problem has bounds on the variables and no other constraints.

c = cons!(nlp, x, c)

Evaluate $c(x)$, the constraints at x in place.

c = cons(nlp, x)

Evaluate $c(x)$, the constraints at x.

c = cons_lin!(nlp, x, c)

Evaluate the linear constraints at x in place.

c = cons_lin(nlp, x)

Evaluate the linear constraints at x.

c = cons_nln!(nlp, x, c)

Evaluate the nonlinear constraints at x in place.

c = cons_nln(nlp, x)

Evaluate the nonlinear constraints at x.

coo_prod!(rows, cols, vals, v, Av)

Compute the product of a matrix A given by (rows, cols, vals) and the vector v. The result is stored in Av, which should have length equals to the number of rows of A.

coo_sym_prod!(rows, cols, vals, v, Av)

Compute the product of a symmetric matrix A given by (rows, cols, vals) and the vector v. The result is stored in Av, which should have length equals to the number of rows of A. Only one triangle of A should be passed.

decrement!(nlp, s)

Decrement counter s of problem nlp.

equality_constrained(nlp)
equality_constrained(meta)

Returns whether the problem's constraints are all equalities. Unconstrained problems return false.

get_ifix(nlp)
get_ifix(meta)

Return the value ifix from meta or nlp.meta.

get_ifree(nlp)
get_ifree(meta)

Return the value ifree from meta or nlp.meta.

get_iinf(nlp)
get_iinf(meta)

Return the value iinf from meta or nlp.meta.

get_ilow(nlp)
get_ilow(meta)

Return the value ilow from meta or nlp.meta.

get_irng(nlp)
get_irng(meta)

Return the value irng from meta or nlp.meta.

get_islp(nlp)
get_islp(meta)

Return the value islp from meta or nlp.meta.

get_iupp(nlp)
get_iupp(meta)

Return the value iupp from meta or nlp.meta.

get_jfix(nlp)
get_jfix(meta)

Return the value jfix from meta or nlp.meta.

get_jfree(nlp)
get_jfree(meta)

Return the value jfree from meta or nlp.meta.

get_jinf(nlp)
get_jinf(meta)

Return the value jinf from meta or nlp.meta.

get_jlow(nlp)
get_jlow(meta)

Return the value jlow from meta or nlp.meta.

get_jrng(nlp)
get_jrng(meta)

Return the value jrng from meta or nlp.meta.

get_jupp(nlp)
get_jupp(meta)

Return the value jupp from meta or nlp.meta.

get_lcon(nlp)
get_lcon(meta)

Return the value lcon from meta or nlp.meta.

get_lin(nlp)
get_lin(meta)

Return the value lin from meta or nlp.meta.

get_lin(nls)
get_lin(nls_meta)

Return the value lin from nls_meta or nls.nls_meta.

get_lin_nnzj(nlp)
get_lin_nnzj(meta)

Return the value lin_nnzj from meta or nlp.meta.

get_lvar(nlp)
get_lvar(meta)

Return the value lvar from meta or nlp.meta.

get_minimize(nlp)
get_minimize(meta)

Return the value minimize from meta or nlp.meta.

get_name(nlp)
get_name(meta)

Return the value name from meta or nlp.meta.

get_ncon(nlp)
get_ncon(meta)

Return the value ncon from meta or nlp.meta.

get_nequ(nls)
get_nequ(nls_meta)

Return the value nequ from nls_meta or nls.nls_meta.

get_nlin(nlp)
get_nlin(meta)

Return the value nlin from meta or nlp.meta.

get_nlin(nls)
get_nlin(nls_meta)

Return the value nlin from nls_meta or nls.nls_meta.

get_nln(nlp)
get_nln(meta)

Return the value nln from meta or nlp.meta.

get_nln(nls)
get_nln(nls_meta)

Return the value nln from nls_meta or nls.nls_meta.

get_nln_nnzj(nlp)
get_nln_nnzj(meta)

Return the value nln_nnzj from meta or nlp.meta.

get_nlvb(nlp)
get_nlvb(meta)

Return the value nlvb from meta or nlp.meta.

get_nlvc(nlp)
get_nlvc(meta)

Return the value nlvc from meta or nlp.meta.

get_nlvo(nlp)
get_nlvo(meta)

Return the value nlvo from meta or nlp.meta.

get_nnln(nlp)
get_nnln(meta)

Return the value nnln from meta or nlp.meta.

get_nnln(nls)
get_nnln(nls_meta)

Return the value nnln from nls_meta or nls.nls_meta.

get_nnzh(nlp)
get_nnzh(meta)

Return the value nnzh from meta or nlp.meta.

get_nnzh(nls)
get_nnzh(nls_meta)

Return the value nnzh from nls_meta or nls.nls_meta.

get_nnzj(nlp)
get_nnzj(meta)

Return the value nnzj from meta or nlp.meta.

get_nnzj(nls)
get_nnzj(nls_meta)

Return the value nnzj from nls_meta or nls.nls_meta.

get_nnzo(nlp)
get_nnzo(meta)

Return the value nnzo from meta or nlp.meta.

get_nvar(nlp)
get_nvar(meta)

Return the value nvar from meta or nlp.meta.

get_nvar(nls)
get_nvar(nls_meta)

Return the value nvar from nls_meta or nls.nls_meta.

get_ucon(nlp)
get_ucon(meta)

Return the value ucon from meta or nlp.meta.

get_uvar(nlp)
get_uvar(meta)

Return the value uvar from meta or nlp.meta.

get_x0(nlp)
get_x0(meta)

Return the value x0 from meta or nlp.meta.

get_x0(nls)
get_x0(nls_meta)

Return the value x0 from nls_meta or nls.nls_meta.

get_y0(nlp)
get_y0(meta)

Return the value y0 from meta or nlp.meta.

ghjvprod!(nlp, x, g, v, gHv)

Return the vector whose i-th component is gᵀ ∇²cᵢ(x) v in place.

gHv = ghjvprod(nlp, x, g, v)

Return the vector whose i-th component is gᵀ ∇²cᵢ(x) v.

g = grad!(nlp, x, g)

Evaluate $∇f(x)$, the gradient of the objective function at x in place.

g = grad!(nls, x, g)
g = grad!(nls, x, g, Fx; recompute::Bool=true)

Evaluate ∇f(x), the gradient of the objective function of nls::AbstractNLSModel at x in place. Fx is overwritten with the value of the residual F(x). If recompute is true, then Fx is updated with the residual at x.

g = grad(nlp, x)

Evaluate $∇f(x)$, the gradient of the objective function at x.

has_bounds(nlp)
has_bounds(meta)

Returns whether the problem has bounds on the variables.

has_equalities(nlp)

Returns whether the problem has constraints and at least one of them is an equality. Unconstrained problems return false.

has_inequalities(nlp)

Returns whether the problem has constraints and at least one of them is an inequality. Unconstrained problems return false.

Hx = hess(nlp, x, y; obj_weight=1.0)

Evaluate the Lagrangian Hessian at (x,y) as a sparse matrix, with objective function scaled by obj_weight, i.e.,

\[∇²L(x,y) = σ ∇²f(x) + \sum_i yᵢ ∇²cᵢ(x),\]

with σ = obj_weight . A Symmetric object wrapping the lower triangle is returned.

Hx = hess(nlp, x; obj_weight=1.0)

Evaluate the objective Hessian at x as a sparse matrix, with objective function scaled by obj_weight, i.e.,

\[σ ∇²f(x),\]

with σ = obj_weight . A Symmetric object wrapping the lower triangle is returned.

vals = hess_coord!(nlp, x, y, vals; obj_weight=1.0)

Evaluate the Lagrangian Hessian at (x,y) in sparse coordinate format, with objective function scaled by obj_weight, i.e.,

\[∇²L(x,y) = σ ∇²f(x) + \sum_i yᵢ ∇²cᵢ(x),\]

with σ = obj_weight , overwriting vals. Only the lower triangle is returned.

vals = hess_coord!(nlp, x, vals; obj_weight=1.0)

Evaluate the objective Hessian at x in sparse coordinate format, with objective function scaled by obj_weight, i.e.,

\[σ ∇²f(x),\]

with σ = obj_weight , overwriting vals. Only the lower triangle is returned.

vals = hess_coord(nlp, x, y; obj_weight=1.0)

Evaluate the Lagrangian Hessian at (x,y) in sparse coordinate format, with objective function scaled by obj_weight, i.e.,

\[∇²L(x,y) = σ ∇²f(x) + \sum_i yᵢ ∇²cᵢ(x),\]

with σ = obj_weight . Only the lower triangle is returned.

vals = hess_coord(nlp, x; obj_weight=1.0)

Evaluate the objective Hessian at x in sparse coordinate format, with objective function scaled by obj_weight, i.e.,

\[σ ∇²f(x),\]

with σ = obj_weight . Only the lower triangle is returned.

vals = hess_coord_residual!(nls, x, v, vals)

Computes the linear combination of the Hessians of the residuals at x with coefficients v in sparse coordinate format, rewriting vals.

vals = hess_coord_residual(nls, x, v)

Computes the linear combination of the Hessians of the residuals at x with coefficients v in sparse coordinate format.

H = hess_op!(nlp, x, y, Hv; obj_weight=1.0)

Return the Lagrangian Hessian at (x,y) with objective function scaled by obj_weight as a linear operator, and storing the result on Hv. The resulting object may be used as if it were a matrix, e.g., w = H * v. The vector Hv is used as preallocated storage for the operation. The linear operator H represents

\[∇²L(x,y) = σ ∇²f(x) + \sum_i yᵢ ∇²cᵢ(x),\]

with σ = obj_weight .

H = hess_op!(nlp, x, Hv; obj_weight=1.0)

Return the objective Hessian at x with objective function scaled by obj_weight as a linear operator, and storing the result on Hv. The resulting object may be used as if it were a matrix, e.g., w = H * v. The vector Hv is used as preallocated storage for the operation. The linear operator H represents

\[σ ∇²f(x),\]

with σ = obj_weight .

H = hess_op!(nlp, rows, cols, vals, Hv)

Return the Hessian given by (rows, cols, vals) as a linear operator, and storing the result on Hv. The resulting object may be used as if it were a matrix, e.g., w = H * v. The vector Hv is used as preallocated storage for the operation. The linear operator H represents

\[σ ∇²f(x),\]

with σ = obj_weight .

H = hess_op(nlp, x, y; obj_weight=1.0)

Return the Lagrangian Hessian at (x,y) with objective function scaled by obj_weight as a linear operator. The resulting object may be used as if it were a matrix, e.g., H * v. The linear operator H represents

\[∇²L(x,y) = σ ∇²f(x) + \sum_i yᵢ ∇²cᵢ(x),\]

with σ = obj_weight .

H = hess_op(nlp, x; obj_weight=1.0)

Return the objective Hessian at x with objective function scaled by obj_weight as a linear operator. The resulting object may be used as if it were a matrix, e.g., H * v. The linear operator H represents

\[σ ∇²f(x),\]

with σ = obj_weight .

Hop = hess_op_residual!(nls, x, i, Hiv)

Computes the Hessian of the i-th residual at x, in linear operator form. The vector Hiv is used as preallocated storage for the operation.

Hop = hess_op_residual(nls, x, i)

Computes the Hessian of the i-th residual at x, in linear operator form.

H = hess_residual(nls, x, v)

Computes the linear combination of the Hessians of the residuals at x with coefficients v. A Symmetric object wrapping the lower triangle is returned.

hess_structure!(nlp, rows, cols)

Return the structure of the Lagrangian Hessian in sparse coordinate format in place.

(rows,cols) = hess_structure(nlp)

Return the structure of the Lagrangian Hessian in sparse coordinate format.

hess_structure_residual!(nls, rows, cols)

Returns the structure of the residual Hessian in place.

(rows,cols) = hess_structure_residual(nls)

Returns the structure of the residual Hessian.

histline(s, v, maxv)

Return a string of the form

______NAME______: ████⋅⋅⋅⋅⋅⋅⋅⋅⋅⋅⋅⋅⋅⋅⋅⋅ 5

where:

• ______NAME______ is s with padding to the left and length 16.
• And the symbols █ and ⋅ fill 20 characters in the proportion of v / maxv to █ and the rest to ⋅.
• The number 5 is v.

Hv = hprod!(nlp, x, y, v, Hv; obj_weight=1.0)

Evaluate the product of the Lagrangian Hessian at (x,y) with the vector v in place, with objective function scaled by obj_weight, where the Lagrangian Hessian is

\[∇²L(x,y) = σ ∇²f(x) + \sum_i yᵢ ∇²cᵢ(x),\]

with σ = obj_weight .

Hv = hprod!(nlp, rows, cols, vals, v, Hv)

Evaluate the product of the objective or Lagrangian Hessian given by (rows, cols, vals) in triplet format with the vector v in place. Only one triangle of the Hessian should be given.

Hv = hprod!(nlp, x, v, Hv; obj_weight=1.0)

Evaluate the product of the objective Hessian at x with the vector v in place, with objective function scaled by obj_weight, where the objective Hessian is

\[σ ∇²f(x),\]

with σ = obj_weight .

Hv = hprod(nlp, x, y, v; obj_weight=1.0)

Evaluate the product of the Lagrangian Hessian at (x,y) with the vector v, with objective function scaled by obj_weight, where the Lagrangian Hessian is

\[∇²L(x,y) = σ ∇²f(x) + \sum_i yᵢ ∇²cᵢ(x),\]

with σ = obj_weight .

Hv = hprod(nlp, x, v; obj_weight=1.0)

Evaluate the product of the objective Hessian at x with the vector v, with objective function scaled by obj_weight, where the objective Hessian is

\[σ ∇²f(x),\]

with σ = obj_weight .

Hiv = hprod_residual!(nls, x, i, v, Hiv)

Computes the product of the Hessian of the i-th residual at x, times the vector v, and stores it in vector Hiv.

Hiv = hprod_residual(nls, x, i, v)

Computes the product of the Hessian of the i-th residual at x, times the vector v.

increment!(nlp, s)

Increment counter s of problem nlp.

increment!(nls, s)

Increment counter s of problem nls.

inequality_constrained(nlp)
inequality_constrained(meta)

Returns whether the problem's constraints are all inequalities. Unconstrained problems return true.

Jx = jac(nlp, x)

Evaluate $J(x)$, the constraints Jacobian at x as a sparse matrix.

vals = jac_coord!(nlp, x, vals)

Evaluate $J(x)$, the constraints Jacobian at x in sparse coordinate format, rewriting vals.

vals = jac_coord(nlp, x)

Evaluate $J(x)$, the constraints Jacobian at x in sparse coordinate format.

vals = jac_coord_residual!(nls, x, vals)

Computes the Jacobian of the residual at x in sparse coordinate format, rewriting vals. rows and cols are not rewritten.

(rows,cols,vals) = jac_coord_residual(nls, x)

Computes the Jacobian of the residual at x in sparse coordinate format.

Jx = jac_lin(nlp, x)

Evaluate $J(x)$, the linear constraints Jacobian at x as a sparse matrix.

vals = jac_lin_coord!(nlp, x, vals)

Evaluate $J(x)$, the linear constraints Jacobian at x in sparse coordinate format, overwriting vals.

vals = jac_lin_coord(nlp, x)

Evaluate $J(x)$, the linear constraints Jacobian at x in sparse coordinate format.

J = jac_lin_op!(nlp, rows, cols, vals, Jv, Jtv)

Return the linear Jacobian given by (rows, cols, vals) as a linear operator. The resulting object may be used as if it were a matrix, e.g., J * v or J' * v. The values Jv and Jtv are used as preallocated storage for the operations.

J = jac_lin_op!(nlp, x, Jv, Jtv)

Return the linear Jacobian at x as a linear operator. The resulting object may be used as if it were a matrix, e.g., J * v or J' * v. The values Jv and Jtv are used as preallocated storage for the operations.

J = jac_lin_op(nlp, x)

Return the linear Jacobian at x as a linear operator. The resulting object may be used as if it were a matrix, e.g., J * v or J' * v.

jac_lin_structure!(nlp, rows, cols)

Return the structure of the linear constraints Jacobian in sparse coordinate format in place.

(rows,cols) = jac_lin_structure(nlp)

Return the structure of the linear constraints Jacobian in sparse coordinate format.

Jx = jac_nln(nlp, x)

Evaluate $J(x)$, the nonlinear constraints Jacobian at x as a sparse matrix.

vals = jac_nln_coord!(nlp, x, vals)

Evaluate $J(x)$, the nonlinear constraints Jacobian at x in sparse coordinate format, overwriting vals.

vals = jac_nln_coord(nlp, x)

Evaluate $J(x)$, the nonlinear constraints Jacobian at x in sparse coordinate format.

J = jac_nln_op!(nlp, rows, cols, vals, Jv, Jtv)

Return the nonlinear Jacobian given by (rows, cols, vals) as a linear operator. The resulting object may be used as if it were a matrix, e.g., J * v or J' * v. The values Jv and Jtv are used as preallocated storage for the operations.

J = jac_nln_op!(nlp, x, Jv, Jtv)

Return the nonlinear Jacobian at x as a linear operator. The resulting object may be used as if it were a matrix, e.g., J * v or J' * v. The values Jv and Jtv are used as preallocated storage for the operations.

J = jac_nln_op(nlp, x)

Return the nonlinear Jacobian at x as a linear operator. The resulting object may be used as if it were a matrix, e.g., J * v or J' * v.

jac_nln_structure!(nlp, rows, cols)

Return the structure of the nonlinear constraints Jacobian in sparse coordinate format in place.

(rows,cols) = jac_nln_structure(nlp)

Return the structure of the nonlinear constraints Jacobian in sparse coordinate format.

J = jac_op!(nlp, rows, cols, vals, Jv, Jtv)

Return the Jacobian given by (rows, cols, vals) as a linear operator. The resulting object may be used as if it were a matrix, e.g., J * v or J' * v. The values Jv and Jtv are used as preallocated storage for the operations.

J = jac_op!(nlp, x, Jv, Jtv)

Return the Jacobian at x as a linear operator. The resulting object may be used as if it were a matrix, e.g., J * v or J' * v. The values Jv and Jtv are used as preallocated storage for the operations.

J = jac_op(nlp, x)

Return the Jacobian at x as a linear operator. The resulting object may be used as if it were a matrix, e.g., J * v or J' * v.

Jx = jac_op_residual!(nls, x, Jv, Jtv)

Computes $J(x)$, the Jacobian of the residual at x, in linear operator form. The vectors Jv and Jtv are used as preallocated storage for the operations.

Jx = jac_op_residual!(nls, rows, cols, vals, Jv, Jtv)

Computes $J(x)$, the Jacobian of the residual given by (rows, cols, vals), in linear operator form. The vectors Jv and Jtv are used as preallocated storage for the operations.

Jx = jac_op_residual(nls, x)

Computes $J(x)$, the Jacobian of the residual at x, in linear operator form.

Jx = jac_residual(nls, x)

Computes $J(x)$, the Jacobian of the residual at x.

jac_structure!(nlp, rows, cols)

Return the structure of the constraints Jacobian in sparse coordinate format in place.

(rows,cols) = jac_structure(nlp)

Return the structure of the constraints Jacobian in sparse coordinate format.

(rows,cols) = jac_structure_residual!(nls, rows, cols)

Returns the structure of the constraint's Jacobian in sparse coordinate format in place.

(rows,cols) = jac_structure_residual(nls)

Returns the structure of the constraint's Jacobian in sparse coordinate format.

Jv = jprod!(nlp, x, v, Jv)

Evaluate $J(x)v$, the Jacobian-vector product at x in place.

Jv = jprod!(nlp, rows, cols, vals, v, Jv)

Evaluate $J(x)v$, the Jacobian-vector product, where the Jacobian is given by (rows, cols, vals) in triplet format.

Jv = jprod(nlp, x, v)

Evaluate $J(x)v$, the Jacobian-vector product at x.

Jv = jprod_lin!(nlp, x, v, Jv)

Evaluate $J(x)v$, the linear Jacobian-vector product at x in place.

Jv = jprod_lin!(nlp, rows, cols, vals, v, Jv)

Evaluate $J(x)v$, the linear Jacobian-vector product, where the Jacobian is given by (rows, cols, vals) in triplet format.

Jv = jprod_lin(nlp, x, v)

Evaluate $J(x)v$, the linear Jacobian-vector product at x.

Jv = jprod_nln!(nlp, x, v, Jv)

Evaluate $J(x)v$, the nonlinear Jacobian-vector product at x in place.

Jv = jprod_nln!(nlp, rows, cols, vals, v, Jv)

Evaluate $J(x)v$, the nonlinear Jacobian-vector product, where the Jacobian is given by (rows, cols, vals) in triplet format.

Jv = jprod_nln(nlp, x, v)

Evaluate $J(x)v$, the nonlinear Jacobian-vector product at x.

Jv = jprod_residual!(nls, x, v, Jv)

Computes the product of the Jacobian of the residual at x and a vector, i.e., $J(x)v$, storing it in Jv.

Jv = jprod_residual!(nls, rows, cols, vals, v, Jv)

Computes the product of the Jacobian of the residual given by (rows, cols, vals) and a vector, i.e., $J(x)v$, storing it in Jv.

Jv = jprod_residual(nls, x, v)

Computes the product of the Jacobian of the residual at x and a vector, i.e., $J(x)v$.

Hx = jth_hess(nlp, x, j)

Evaluate the Hessian of j-th constraint at x as a sparse matrix with the same sparsity pattern as the Lagrangian Hessian. A Symmetric object wrapping the lower triangle is returned.

vals = jth_hess_coord!(nlp, x, j, vals)

Evaluate the Hessian of j-th constraint at x in sparse coordinate format, with vals of length nlp.meta.nnzh, in place. Only the lower triangle is returned.

vals = jth_hess_coord(nlp, x, j)

Evaluate the Hessian of j-th constraint at x in sparse coordinate format. Only the lower triangle is returned.

Hj = jth_hess_residual(nls, x, j)

Computes the Hessian of the j-th residual at x.

Hv = jth_hprod!(nlp, x, v, j, Hv)

Evaluate the product of the Hessian of j-th constraint at x with the vector v in place.

Hv = jth_hprod(nlp, x, v, j)

Evaluate the product of the Hessian of j-th constraint at x with the vector v.

Jtv = jtprod!(nlp, x, v, Jtv)

Evaluate $J(x)^Tv$, the transposed-Jacobian-vector product at x in place. If the problem has linear and nonlinear constraints, this function allocates.

Jtv = jtprod!(nlp, rows, cols, vals, v, Jtv)

Evaluate $J(x)^Tv$, the transposed-Jacobian-vector product, where the Jacobian is given by (rows, cols, vals) in triplet format.

Jtv = jtprod(nlp, x, v)

Evaluate $J(x)^Tv$, the transposed-Jacobian-vector product at x.

Jtv = jtprod_lin!(nlp, x, v, Jtv)

Evaluate $J(x)^Tv$, the linear transposed-Jacobian-vector product at x in place.

Jtv = jtprod_lin!(nlp, rows, cols, vals, v, Jtv)

Evaluate $J(x)^Tv$, the linear transposed-Jacobian-vector product, where the Jacobian is given by (rows, cols, vals) in triplet format.

Jtv = jtprod_lin(nlp, x, v)

Evaluate $J(x)^Tv$, the linear transposed-Jacobian-vector product at x.

Jtv = jtprod_nln!(nlp, x, v, Jtv)

Evaluate $J(x)^Tv$, the nonlinear transposed-Jacobian-vector product at x in place.

Jtv = jtprod_nln!(nlp, rows, cols, vals, v, Jtv)

Evaluate $J(x)^Tv$, the nonlinear transposed-Jacobian-vector product, where the Jacobian is given by (rows, cols, vals) in triplet format.

Jtv = jtprod_nln(nlp, x, v)

Evaluate $J(x)^Tv$, the nonlinear transposed-Jacobian-vector product at x.

Jtv = jtprod_residual!(nls, x, v, Jtv)

Computes the product of the transpose of the Jacobian of the residual at x and a vector, i.e., $J(x)^Tv$, storing it in Jtv.

Jtv = jtprod_residual!(nls, rows, cols, vals, v, Jtv)

Computes the product of the transpose of the Jacobian of the residual given by (rows, cols, vals) and a vector, i.e., $J(x)^Tv$, storing it in Jv.

Jtv = jtprod_residual(nls, x, v)

Computes the product of the transpose of the Jacobian of the residual at x and a vector, i.e., $J(x)^Tv$.

linearly_constrained(nlp)
linearly_constrained(meta)

Returns whether the problem's constraints are known to be all linear.

lines_of_description(meta)

Describe meta for the show function.

lines_of_description(nls_meta)

Describe nls_meta for the show function.

lines_of_hist(S, V)

Return a vector of histline(s, v, maxv)s using pairs of s in S and v in V. maxv is given by the maximum of V.

neval_cons(nlp)

Get the number of cons evaluations.

neval_cons_lin(nlp)

Get the number of cons evaluations.

neval_cons_nln(nlp)

Get the number of cons evaluations.

neval_grad(nlp)

Get the number of grad evaluations.

neval_hess(nlp)

Get the number of hess evaluations.

nevalhessresidual(nlp)

Get the number of hess evaluations.

neval_hprod(nlp)

Get the number of hprod evaluations.

nevalhprodresidual(nlp)

Get the number of hprod evaluations.

neval_jac(nlp)

Get the number of jac evaluations.

neval_jac_lin(nlp)

Get the number of jac evaluations.

neval_jac_nln(nlp)

Get the number of jac evaluations.

nevaljacresidual(nlp)

Get the number of jac evaluations.

neval_jcon(nlp)

Get the number of jcon evaluations.

neval_jgrad(nlp)

Get the number of jgrad evaluations.

neval_jhess(nlp)

Get the number of jhess evaluations.

nevaljhessresidual(nlp)

Get the number of jhess evaluations.

neval_jhprod(nlp)

Get the number of jhprod evaluations.

neval_jprod(nlp)

Get the number of jprod evaluations.

neval_jprod_lin(nlp)

Get the number of jprod evaluations.

neval_jprod_nln(nlp)

Get the number of jprod evaluations.

nevaljprodresidual(nlp)

Get the number of jprod evaluations.

neval_jtprod(nlp)

Get the number of jtprod evaluations.

neval_jtprod_lin(nlp)

Get the number of jtprod evaluations.

neval_jtprod_nln(nlp)

Get the number of jtprod evaluations.

nevaljtprodresidual(nlp)

Get the number of jtprod evaluations.

neval_obj(nlp)

Get the number of obj evaluations.

neval_residual(nlp)

Get the number of residual evaluations.

nls_meta(nls)

Returns the nls_meta structure of nls. Use this instead of nls.nls_meta to handle models that have internal models.

For basic models nls_meta(nls) is defined as nls.nls_meta, but composite models might not keep nls_meta themselves, so they might specialize it to something like nls.internal.nls_meta.

f = obj(nlp, x)

Evaluate $f(x)$, the objective function of nlp at x.

f = obj(nls, x)
f = obj(nls, x, Fx; recompute::Bool=true)

Evaluate f(x), the objective function of nls::AbstractNLSModel. Fx is overwritten with the value of the residual F(x). If recompute is true, then Fx is updated with the residual at x.

f, c = objcons!(nlp, x, c)

Evaluate $f(x)$ and $c(x)$ at x. c is overwritten with the value of $c(x)$.

f, c = objcons(nlp, x)

Evaluate $f(x)$ and $c(x)$ at x.

f, g = objgrad!(nlp, x, g)

Evaluate $f(x)$ and $∇f(x)$ at x. g is overwritten with the value of $∇f(x)$.

f, g = objgrad!(nls, x, g)
f, g = objgrad!(nls, x, g, Fx; recompute::Bool=true)

Evaluate f(x) and ∇f(x) of nls::AbstractNLSModel at x. Fx is overwritten with the value of the residual F(x). If recompute is true, then Fx is updated with the residual at x.

f, g = objgrad(nlp, x)

Evaluate $f(x)$ and $∇f(x)$ at x.

reset_data!(nlp)

Reset model data if appropriate. This method should be overloaded if a subtype of AbstractNLPModel contains data that should be reset, such as a quasi-Newton linear operator.

Fx = residual!(nls, x, Fx)

Computes $F(x)$, the residual at x.

Fx = residual(nls, x)

Computes $F(x)$, the residual at x.

show_counters(io, counters, fields)

Show the fields of the struct counters.

show_header(io, nlp)

Show a header for the specific nlp type. Should be imported and defined for every model implementing the NLPModels API.

sparsityline(s, v, maxv)

Return a string of the form

______NAME______: ( 80.00% sparsity)   5

where:

• ______NAME______ is s with padding to the left and length 16.
• The sparsity value is given by v / maxv.
• The number 5 is v.

sum_counters(nlp)

Sum all counters of problem nlp except cons, jac, jprod and jtprod.

sum_counters(counters)

Sum all counters of counters except cons, jac, jprod and jtprod.

unconstrained(nlp)
unconstrained(meta)

Returns whether the problem in unconstrained.

@default_counters Model inner

Define functions relating counters of Model to counters of Model.inner.

@default_nlscounters Model inner

Define functions relating NLS counters of Model to NLS counters of Model.inner.

@lencheck n x y z …

Check that arrays x, y, z, etc. have a prescribed length n.

@rangecheck ℓ u i j k …

Check that values i, j, k, etc. are in the range [ℓ,u].