Reference

Contents

Index

CUTEst.CUTEstModelMethod
nlp = CUTEstModel(name, args...; kwargs...)

Creates a CUTEst model following the NLPModels API. This model needs to be finalized before a new one is created (e.g., calling finalize(nlp)).

Optional arguments

Any extra arguments will be passed to sifdecoder. You can, for instance, change parameters of the model:

using CUTEst

nlp = CUTEstModel("CHAIN", "-param", "NH=50")
println(nlp.meta.nnzh)
finalize(nlp)
nlp = CUTEstModel("CHAIN", "-param", "NH=100")
println(nlp.meta.nnzh)
finalize(nlp)

# output

153
303

Keyword arguments

  • decode::Bool = true: Whether to call sifdecoder.
  • verbose::Bool = false: Passed to sifdecoder.
  • efirst::Bool = true`: Equalities first?
  • lfirst::Bool = true`: Linear (or affine) constraints first?
  • lvfirst::Bool = true: Nonlinear variables should appear first?
source
CUTEst.ccfgMethod

ccfg

The ccfg subroutine evaluates the values of the constraint functions of the problem decoded from a SIF file by the script sifdecoder at the point X, and possibly their gradients. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_ccfg

Usage:

ccfg(io_err, n, m, x, c, jtrans, lcjac1, lcjac2, cjac, grad)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • c: [OUT] Vector{Cdouble}
  • jtrans: [IN] Vector{Cint}
  • lcjac1: [IN] Vector{Cint}
  • lcjac2: [IN] Vector{Cint}
  • cjac: [OUT] Array{Cdouble, 2}
  • grad: [IN] Vector{Cint}
source
CUTEst.ccfsgMethod

ccfsg

The ccfsg subroutine evaluates the values of the constraint functions of the problem decoded from a SIF file by the script sifdecoder at the point X, and possibly their gradients in the constrained minimization case. The gradients are stored in sparse format. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_ccfsg

Usage:

ccfsg(io_err, n, m, x, c, nnzj, lj, j_val, j_var, j_fun, grad)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • c: [OUT] Vector{Cdouble}
  • nnzj: [OUT] Vector{Cint}
  • lj: [IN] Vector{Cint}
  • j_val: [OUT] Vector{Cdouble}
  • j_var: [OUT] Vector{Cint}
  • j_fun: [OUT] Vector{Cint}
  • grad: [IN] Vector{Cint}
source
CUTEst.cchprodsMethod

cchprods

The cchprods subroutine forms the product of a vector with each of the Hessian matrix of the constraint functions c(x) corresponding to the problem decoded from a SIF file by the script sifdecoder at the point x= X. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cchprods

Usage:

cchprods(io_err, n, m, goth, x, vector, lchp, chp_val, chp_ind, chp_ptr)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • goth: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • vector: [IN] Vector{Cdouble}
  • lchp: [IN] Vector{Cint}
  • chp_val: [OUT] Vector{Cdouble}
  • chp_ind: [IN] Vector{Cint}
  • chp_ptr: [IN] Vector{Cint}
source
CUTEst.cchprodspMethod

cchprodsp

The cchprodsp subroutine obtains the sparsity structure used when forming the product of a vector with each of the Hessian matrices of the constraint functions c(x) corresponding to the problem decoded from a SIF file by the script sifdecoder at the point x= X.

Usage:

cchprodsp(io_err, m, lchp, chp_ind, chp_ptr)
  • io_err: [OUT] Vector{Cint}
  • m: [IN] Vector{Cint}
  • lchp: [IN] Vector{Cint}
  • chp_ind: [IN] Vector{Cint}
  • chp_ptr: [IN] Vector{Cint}
source
CUTEst.ccifgMethod

ccifg

The ccifg subroutine evaluates the value of a particular constraint function of the problem decoded from a SIF file by the script sifdecoder at the point X, and possibly its gradient in the constrained minimization case. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_ccifg

Usage:

ccifg(io_err, n, icon, x, ci, gci, grad)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • icon: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • ci: [OUT] Vector{Cdouble}
  • gci: [OUT] Vector{Cdouble}
  • grad: [IN] Vector{Cint}
source
CUTEst.ccifsgMethod

ccifsg

The ccifsg subroutine evaluates the value of a particular constraint function of the problem decoded from a SIF file by the script sifdecoder at the point X, and possibly its gradient in the constrained minimization case. The gradient is stored in sparse format. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_ccifsg

Usage:

ccifsg(io_err, n, icon, x, ci, nnzgci, lgci, gci_val, gci_var, grad)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • icon: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • ci: [OUT] Vector{Cdouble}
  • nnzgci: [OUT] Vector{Cint}
  • lgci: [IN] Vector{Cint}
  • gci_val: [OUT] Vector{Cdouble}
  • gci_var: [OUT] Vector{Cint}
  • grad: [IN] Vector{Cint}
source
CUTEst.cdhMethod

cdh

The cdh subroutine evaluates the Hessian matrix of the Lagrangian function l(x,y)=f(x)+yTc(x) for the problem decoded from a SIF file by the script sifdecoder at the point (x,y)= (X,Y). The matrix is stored as a dense matrix. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cdh

Usage:

cdh(io_err, n, m, x, y, lh1, h_val)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • y: [IN] Vector{Cdouble}
  • lh1: [IN] Vector{Cint}
  • h_val: [OUT] Array{Cdouble, 2}
source
CUTEst.cdhcMethod

cdhc

The cdhc subroutine evaluates the Hessian matrix of the constraint part of the Lagrangian function yTc(x) for the problem decoded from a SIF file by the script sifdecoder at the point (x,y)= (X,Y). The matrix is stored as a dense matrix. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cdhc

Usage:

cdhc(io_err, n, m, x, y, lh1, h_val)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • y: [IN] Vector{Cdouble}
  • lh1: [IN] Vector{Cint}
  • h_val: [OUT] Array{Cdouble, 2}
source
CUTEst.cdimchpMethod

cdimchp

The cdimchp subroutine determines the number of nonzero elements required to store the products of the Hessian matrices of the constraint functions with a specified vector for the problem decoded into OUTSDIF.d in the constrained minimization case. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cdimchp

Usage:

cdimchp(io_err, nnzchp)
  • io_err: [OUT] Vector{Cint}
  • nnzchp: [OUT] Vector{Cint}
source
CUTEst.cdimenMethod

cdimen

The cdimen subroutine discovers how many variables and constraints are involved in the problem decoded from a SIF file by the script sifdecoder. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cdimen

Usage:

cdimen(io_err, input, n, m)
  • io_err: [OUT] Vector{Cint}
  • input: [IN] Vector{Cint}
  • n: [OUT] Vector{Cint}
  • m: [OUT] Vector{Cint}
source
CUTEst.cdimseMethod

cdimse

The cdimse subroutine determines the number of nonzero elements required to store the Hessian matrix of the Lagrangian function for the problem decoded from a SIF file by the script sifdecoder. The matrix is stored in sparse "finite element" format H=eΣ1He, where each square symmetric element He involves a small subset of the rows of the Hessian matrix. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cdimse

Usage:

cdimse(io_err, ne, he_val_ne, he_row_ne)
  • io_err: [OUT] Vector{Cint}
  • ne: [OUT] Vector{Cint}
  • hevalne: [OUT] Vector{Cint}
  • herowne: [OUT] Vector{Cint}
source
CUTEst.cdimshMethod

cdimsh

The cdimsh subroutine determines the number of nonzero elements required to store the Hessian matrix of the Lagrangian function for the problem decoded into OUTSDIF.d in the constrained minimization case. The matrix is stored in sparse "coordinate" format. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cdimsh

Usage:

cdimsh(io_err, nnzh)
  • io_err: [OUT] Vector{Cint}
  • nnzh: [OUT] Vector{Cint}
source
CUTEst.cdimsjMethod

cdimsj

The cdimsj subroutine determines the number of nonzero elements required to store the matrix of gradients of the objective function and constraint functions for the problem decoded into OUTSDIF.d in the constrained minimization case. The matrix is stored in sparse format. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cdimsj

Usage:

cdimsj(io_err, nnzj)
  • io_err: [OUT] Vector{Cint}
  • nnzj: [OUT] Vector{Cint}
source
CUTEst.cehMethod

ceh

The ceh subroutine evaluates the Hessian matrix of the Lagrangian function l(x,y)=f(x)+yTc(x) for the problem decoded into OUTSDIF.d at the point (x,y)= (X,Y). This Hessian matrix is stored as a sparse matrix in finite element format H=eΣ1He, where each square symmetric element He involves a small subset of the rows of the Hessian matrix. The problem under consideration consists in minimizing (or maximizing) an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_ceh

Usage:

ceh(io_err, n, m, x, y, ne, lhe_ptr, he_row_ptr, he_val_ptr, lhe_row,

herow, lheval, he_val, byrows)

  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • y: [IN] Vector{Cdouble}
  • ne: [OUT] Vector{Cint}
  • lhe_ptr: [IN] Vector{Cint}
  • herowptr: [OUT] Vector{Cint}
  • hevalptr: [OUT] Vector{Cint}
  • lhe_row: [IN] Vector{Cint}
  • he_row: [OUT] Vector{Cint}
  • lhe_val: [IN] Vector{Cint}
  • he_val: [OUT] Vector{Cdouble}
  • byrows: [IN] Vector{Cint}
source
CUTEst.cfnMethod

cfn

The cfn subroutine evaluates the value of the objective function and general constraint functions of the problem decoded from a SIF file by the script sifdecoder at the point X. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cfn

Usage:

cfn(io_err, n, m, x, f, c)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • f: [OUT] Vector{Cdouble}
  • c: [OUT] Vector{Cdouble}
source
CUTEst.cgrMethod

cgr

The cgr subroutine evaluates the gradients of the general constraints and of either the objective function f(x) or the Lagrangian function l(x,y)=f(x)+yTc(x) corresponding to the problem decoded from a SIF file by the script sifdecoder at the point (x,y)= (X,Y). The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cgr

Usage:

cgr(io_err, n, m, x, y, grlagf, g, jtrans, lj1, lj2, j_val)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • y: [IN] Vector{Cdouble}
  • grlagf: [IN] Vector{Cint}
  • g: [OUT] Vector{Cdouble}
  • jtrans: [IN] Vector{Cint}
  • lj1: [IN] Vector{Cint}
  • lj2: [IN] Vector{Cint}
  • j_val: [OUT] Array{Cdouble, 2}
source
CUTEst.cgrdhMethod

cgrdh

The cgrdh subroutine evaluates the gradients of the general constraints and of either the objective function f(x) or the Lagrangian function l(x,y)=f(x)+yTc(x) corresponding to the problem decoded from a SIF file by the script sifdecoder at the point (x,y)= (X,Y). It also evaluates the Hessian matrix of the Lagrangian function at (x,y). The gradients and matrices are stored in a dense format. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cgrdh

Usage:

cgrdh(io_err, n, m, x, y, grlagf, g, jtrans, lj1, lj2, j_val, lh1, h_val)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • y: [IN] Vector{Cdouble}
  • grlagf: [IN] Vector{Cint}
  • g: [OUT] Vector{Cdouble}
  • jtrans: [IN] Vector{Cint}
  • lj1: [IN] Vector{Cint}
  • lj2: [IN] Vector{Cint}
  • j_val: [OUT] Array{Cdouble, 2}
  • lh1: [IN] Vector{Cint}
  • h_val: [OUT] Array{Cdouble, 2}
source
CUTEst.chcprodMethod

chcprod

The chcprod subroutine forms the product of a vector with the Hessian matrix of the constraint part of the Lagrangian function yTc(x) of the problem decoded from a SIF file by the script sifdecoder at the point (x,y)= (X,Y). The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_chcprod

Usage:

chcprod(io_err, n, m, goth, x, y, vector, result)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • goth: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • y: [IN] Vector{Cdouble}
  • vector: [IN] Vector{Cdouble}
  • result: [OUT] Vector{Cdouble}
source
CUTEst.chprodMethod

chprod

The chprod subroutine forms the product of a vector with the Hessian matrix of the Lagrangian function l(x,y)=f(x)+yTc(x) corresponding to the problem decoded from a SIF file by the script sifdecoder at the point (x,y)= (X,Y). The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_chprod

Usage:

chprod(io_err, n, m, goth, x, y, vector, result)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • goth: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • y: [IN] Vector{Cdouble}
  • vector: [IN] Vector{Cdouble}
  • result: [OUT] Vector{Cdouble}
source
CUTEst.cidhMethod

cidh

The cidh subroutine evaluates the Hessian matrix of either the objective function or a constraint function for the problem decoded from a SIF file by the script sifdecoder at the point X, and possibly its gradient. The matrix is stored as a dense matrix. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cidh

Usage:

cidh(io_err, n, x, iprob, lh1, h)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • iprob: [IN] Vector{Cint}
  • lh1: [IN] Vector{Cint}
  • h: [OUT] Array{Cdouble, 2}
source
CUTEst.cifnMethod

cifn

The cifn subroutine evaluates the value of either the objective function or a constrainted function of the problem decoded from a SIF file by the script sifdecoder at the point X, in the constrained minimization case.

For more information, run the shell command

man cutest_cifn

Usage:

  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • iprob: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • f: [OUT] Vector{Cdouble}
source
CUTEst.cigrMethod

cigr

The cigr subroutine evaluates the gradient of either the objective function or a constraint function of the problem decoded from a SIF file by the script sifdecoder at the point X, in the constrained minimization case.

For more information, run the shell command

man cutest_cigr
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • iprob: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • g_val: [OUT] Vector{Cdouble}
source
CUTEst.cisgrMethod

cisgr

The cisgr subroutine evaluates the gradient of either the objective function or a constraint function of the problem decoded from a SIF file by the script sifdecoder at the point X, in the constrained minimization case. The gradient is stored in sparse format.

For more information, run the shell command

man cutest_cisgr

Usage:

  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • iprob: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • nnzg: [OUT] Vector{Cint}
  • lg: [IN] Vector{Cint}
  • g_val: [OUT] Vector{Cdouble}
  • g_var: [OUT] Vector{Cint}
source
CUTEst.cishMethod

cish

The cish subroutine evaluates the Hessian of a particular constraint function or the objective function for the problem decoded from a SIF file by the script sifdecoder at the point X, and possibly its gradient. The matrix is stored in sparse format. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cish

Usage:

cish(io_err, n, x, iprob, nnzh, lh, h_val, h_row, h_col)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • iprob: [IN] Vector{Cint}
  • nnzh: [OUT] Vector{Cint}
  • lh: [IN] Vector{Cint}
  • h_val: [OUT] Vector{Cdouble}
  • h_row: [OUT] Vector{Cint}
  • h_col: [OUT] Vector{Cint}
source
CUTEst.cjprodMethod

cjprod

The cjprod subroutine forms the product of a vector with the Jacobian matrix, or with its transpose, of the constraint functions of the problem decoded from a SIF file by the script sifdecoder evaluated at the point X. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cjprod

Usage:

cjprod(io_err, n, m, gotj, jtrans, x, vector, lvector, result, lresult)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • gotj: [IN] Vector{Cint}
  • jtrans: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • vector: [IN] Vector{Cdouble}
  • lvector: [IN] Vector{Cint}
  • result: [OUT] Vector{Cdouble}
  • lresult: [IN] Vector{Cint}
source
CUTEst.clfgMethod

clfg

The clfg subroutine evaluates the value of the Lagrangian function l(x,y)=f(x)+yTc(x) for the problem decoded from a SIF file by the script sifdecoder at the point (X,Y), and possibly its gradient. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_clfg

Usage:

clfg(io_err, n, m, x, y, f, g, grad)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • y: [IN] Vector{Cdouble}
  • f: [OUT] Vector{Cdouble}
  • g: [OUT] Vector{Cdouble}
  • grad: [IN] Vector{Cint}
source
CUTEst.cnamesMethod

cnames

The cnames subroutine obtains the names of the problem, its variables and general constraints. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cnames

Usage:

cnames(io_err, n, m, pname, vname, cname)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • pname: [OUT] Vector{UInt8}
  • vname: [OUT] Vector{UInt8}
  • cname: [OUT] Vector{UInt8}

To get useful names, use String(x) where x can be pname, vname[:,i], or cname[:,i].

source
CUTEst.cofgMethod

cofg

The cofg subroutine evaluates the value of the objective function of the problem decoded from a SIF file by the script sifdecoder at the point X, and possibly its gradient. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cofg

Usage:

cofg(io_err, n, x, f, g, grad)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • f: [OUT] Vector{Cdouble}
  • g: [OUT] Vector{Cdouble}
  • grad: [IN] Vector{Cint}
source
CUTEst.cofsgMethod

cofsg

The cofsg subroutine evaluates the value of the objective function of the problem decoded from a SIF file by the script sifdecoder at the point X, and possibly its gradient in sparse format. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cofsg

Usage:

cofsg(io_err, n, x, f, nnzg, lg, g_val, g_var, grad)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • f: [OUT] Vector{Cdouble}
  • nnzg: [OUT] Vector{Cint}
  • lg: [IN] Vector{Cint}
  • g_val: [OUT] Vector{Cdouble}
  • g_var: [OUT] Vector{Cint}
  • grad: [IN] Vector{Cint}
source
CUTEst.connamesMethod

connames

The connames subroutine obtains the names of the general constraints of the problem. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_connames

Usage:

connames(io_err, m, cname)
  • io_err: [OUT] Vector{Cint}
  • m: [IN] Vector{Cint}
  • cname: [OUT] Vector{UInt8}

To get useful names, use String(cname[:,i]).

source
CUTEst.cons_coord!Method
cons_coord!(nlp, x, c, rows, cols, vals)

Computes the constraint vector and the Jacobian in coordinate format. Usage:

cons_coord!(nlp, x, c, rows, cols, vals)
  • nlp: [IN] CUTEstModel
  • x: [IN] Vector{Float64}
  • c: [OUT] Vector{Float64}
  • jrow: [OUT] Vector{Int32}
  • jcol: [OUT] Vector{Int32}
  • jval: [OUT] Vector{Float64}
source
CUTEst.cons_coordMethod
cons_coord(nlp, x)

Computes the constraint vector and the Jacobian in coordinate format. Usage:

c, jrow, jcol, jval = cons_coord(nlp, x)
  • nlp: [IN] CUTEstModel
  • x: [IN] Vector{Float64}
  • c: [OUT] Vector{Float64}
  • jrow: [OUT] Vector{Int32}
  • jcol: [OUT] Vector{Int32}
  • jval: [OUT] Vector{Float64}
source
CUTEst.consjacMethod
consjac(nlp, x)

Computes the constraint vector and the Jacobian in internal sparse format. Usage:

c, J = consjac(nlp, x)
  • nlp: [IN] CUTEstModel
  • x: [IN] Vector{Float64}
  • c: [OUT] Vector{Float64}
  • J: [OUT] Base.SparseMatrix.SparseMatrixCSC{Float64,Int32}
source
CUTEst.creportMethod

creport

The creport subroutine obtains statistics concerning function evaluation and CPU time used for constrained optimization in a standardized format. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_creport

Usage:

creport(io_err, calls, time)
  • io_err: [OUT] Vector{Cint}
  • calls: [OUT] Vector{Cdouble}
  • time: [OUT] Vector{Cdouble}
source
CUTEst.csetupMethod

csetup

The csetup subroutine sets up the correct data structures for subsequent computations on the problem decoded from a SIF file by the script sifdecoder. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_csetup

Usage:

csetup(io_err, input, out, io_buffer, n, m, x, x_l, x_u, y, c_l, c_u, equatn,

linear, eorder, lorder, v_order)

  • io_err: [OUT] Vector{Cint}
  • input: [IN] Vector{Cint}
  • out: [IN] Vector{Cint}
  • io_buffer: [IN] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • x: [OUT] Vector{Cdouble}
  • x_l: [OUT] Vector{Cdouble}
  • x_u: [OUT] Vector{Cdouble}
  • y: [OUT] Vector{Cdouble}
  • c_l: [OUT] Vector{Cdouble}
  • c_u: [OUT] Vector{Cdouble}
  • equatn: [OUT] Vector{Cint}
  • linear: [OUT] Vector{Cint}
  • e_order: [IN] Vector{Cint}
  • l_order: [IN] Vector{Cint}
  • v_order: [IN] Vector{Cint}
source
CUTEst.csgrMethod

csgr

The csgr subroutine evaluates the gradients of the general constraints and of either the objective function or the Lagrangian function l(x,y)=f(x)+yTc(x) corresponding to the problem decoded from a SIF file by the script sifdecoder at the point (x,y)= (X,Y). It also evaluates the Hessian matrix of the Lagrangian function at (x,y). The gradients are stored in a sparse format. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_csgr

Usage:

csgr(io_err, n, m, x, y, grlagf, nnzj, lj, j_val, j_var, j_fun)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • y: [IN] Vector{Cdouble}
  • grlagf: [IN] Vector{Cint}
  • nnzj: [OUT] Vector{Cint}
  • lj: [IN] Vector{Cint}
  • j_val: [OUT] Vector{Cdouble}
  • j_var: [OUT] Vector{Cint}
  • j_fun: [OUT] Vector{Cint}
source
CUTEst.csgrehMethod

csgreh

The csgreh subroutine evaluates both the gradients of the general constraint functions and the Hessian matrix of the Lagrangian function l(x,y)=f(x)+yTc(x) for the problem decoded into OUTSDIF.d at the point (x,y)= (X,Y). This Hessian matrix is stored as a sparse matrix in finite element format H=eΣ1He, where each square symmetric element He involves a small subset of the rows of the Hessian matrix. The subroutine also obtains the gradient of either the objective function or the Lagrangian function, stored in a sparse format. The problem under consideration consists in minimizing (or maximizing) an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_csgreh

Usage:

csgreh(io_err, n, m, x, y, grlagf, nnzj, lj, j_val, j_var, j_fun, ne,

lheptr, herowptr, hevalptr, lherow, herow, lheval, he_val, byrows)

  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • y: [IN] Vector{Cdouble}
  • grlagf: [IN] Vector{Cint}
  • nnzj: [OUT] Vector{Cint}
  • lj: [IN] Vector{Cint}
  • j_val: [OUT] Vector{Cdouble}
  • j_var: [OUT] Vector{Cint}
  • j_fun: [OUT] Vector{Cint}
  • ne: [OUT] Vector{Cint}
  • lhe_ptr: [IN] Vector{Cint}
  • herowptr: [OUT] Vector{Cint}
  • hevalptr: [OUT] Vector{Cint}
  • lhe_row: [IN] Vector{Cint}
  • he_row: [OUT] Vector{Cint}
  • lhe_val: [IN] Vector{Cint}
  • he_val: [OUT] Vector{Cdouble}
  • byrows: [IN] Vector{Cint}
source
CUTEst.csgrpMethod

csgrp

The csgrp subroutine evaluates sparsity pattern used when storing the gradients of the general constraints and of either the objective function or the Lagrangian function l(x,y)=f(x)+yTc(x) corresponding to the problem decoded from a SIF file by the script sifdecoder.

For more information, run the shell command

man cutest_csgrp

Usage:

csgrp(io_err, n, nnzj, lj, j_var, j_fun)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • nnzj: [OUT] Vector{Cint}
  • lj: [IN] Vector{Cint}
  • j_var: [OUT] Vector{Cint}
  • j_fun: [OUT] Vector{Cint}
source
CUTEst.csgrshMethod

csgrsh

The csgrsh subroutine evaluates the gradients of the general constraints, the Hessian matrix of the Lagrangian function l(x,y)=f(x)+yTc(x) and the gradient of either the objective function or the Lagrangian corresponding to the problem decoded from a SIF file by the script sifdecoder at the point (x,y)= (X,Y). The data is stored in sparse format. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_csgrsh

Usage:

csgrsh(io_err, n, m, x, y, grlagf, nnzj, lj, j_val, j_var, j_fun, nnzh, lh,

hval, hrow, h_col)

  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • y: [IN] Vector{Cdouble}
  • grlagf: [IN] Vector{Cint}
  • nnzj: [OUT] Vector{Cint}
  • lj: [IN] Vector{Cint}
  • j_val: [OUT] Vector{Cdouble}
  • j_var: [OUT] Vector{Cint}
  • j_fun: [OUT] Vector{Cint}
  • nnzh: [OUT] Vector{Cint}
  • lh: [IN] Vector{Cint}
  • h_val: [OUT] Vector{Cdouble}
  • h_row: [OUT] Vector{Cint}
  • h_col: [OUT] Vector{Cint}
source
CUTEst.csgrshpMethod

csgrshp

The csgrshp subroutine evaluates sparsity pattern used when storing the gradients of the general constraints and of either the objective function or the Lagrangian function l(x,y)=f(x)+yTc(x), as well as the Hessian of the Lagrangian function, corresponding to the problem decoded from a SIF file by the script sifdecoder.

For more information, run the shell command

man cutest_csgrshp
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • nnzj: [OUT] Vector{Cint}
  • lj: [IN] Vector{Cint}
  • j_var: [OUT] Vector{Cint}
  • j_fun: [OUT] Vector{Cint}
  • nnzh: [OUT] Vector{Cint}
  • lh: [IN] Vector{Cint}
  • h_row: [OUT] Vector{Cint}
  • h_col: [OUT] Vector{Cint}
source
CUTEst.cshMethod

csh

The csh subroutine evaluates the Hessian of the Lagrangian function l(x,y)=f(x)+yTc(x) for the problem decoded from a SIF file by the script sifdecoder at the point (x,y)= (X,Y). The matrix is stored in sparse format. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_csh

Usage:

csh(io_err, n, m, x, y, nnzh, lh, h_val, h_row, h_col)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • y: [IN] Vector{Cdouble}
  • nnzh: [OUT] Vector{Cint}
  • lh: [IN] Vector{Cint}
  • h_val: [OUT] Vector{Cdouble}
  • h_row: [OUT] Vector{Cint}
  • h_col: [OUT] Vector{Cint}
source
CUTEst.cshcMethod

cshc

The cshc subroutine evaluates the Hessian matrix of the constraint part of the Lagrangian function yTc(x) for the problem decoded from a SIF file by the script sifdecoder at the point (x,y)= (X,Y). The matrix is stored in sparse format. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cshc

Usage:

cshc(io_err, n, m, x, y, nnzh, lh, h_val, h_row, h_col)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • y: [IN] Vector{Cdouble}
  • nnzh: [OUT] Vector{Cint}
  • lh: [IN] Vector{Cint}
  • h_val: [OUT] Vector{Cdouble}
  • h_row: [OUT] Vector{Cint}
  • h_col: [OUT] Vector{Cint}
source
CUTEst.cshcprodMethod

cshcprod

The cshcprod subroutine forms the product of a sparse vector with the Hessian matrix of the constraint part of the Lagrangian function yTc(x) corresponding to the problem decoded from a SIF file by the script sifdecoder at the point (x,y)= (X,Y). The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cshcprod

Usage:

cshcprod(io_err, n, m, goth, x, y, nnz_vector, index_nz_vector, vector,

nnzresult, indexnz_result, result)

  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • goth: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • y: [IN] Vector{Cdouble}
  • nnz_vector: [IN] Vector{Cint}
  • indexnzvector: [IN] Vector{Cint}
  • vector: [IN] Vector{Cdouble}
  • nnz_result: [OUT] Vector{Cint}
  • indexnzresult: [OUT] Vector{Cint}
  • result: [OUT] Vector{Cdouble}
source
CUTEst.cshpMethod

cshp

The cshp subroutine evaluates the sparsity pattern of the Hessian of the Lagrangian function l(x,y)=f(x)+yTc(x) for the problem, decoded from a SIF file by the script sifdecoder, in coordinate format. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cshp

Usage:

cshp(io_err, n, nnzh, lh, h_row, h_col)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • nnzh: [OUT] Vector{Cint}
  • lh: [IN] Vector{Cint}
  • h_row: [OUT] Vector{Cint}
  • h_col: [OUT] Vector{Cint}
source
CUTEst.cshprodMethod

cshprod

The cshprod subroutine forms the product of a sparse vector with the Hessian matrix of the Lagrangian function l(x,y)=f(x)+yTc(x) corresponding to the problem decoded from a SIF file by the script sifdecoder at the point (x,y)= (X,Y). The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cshprod

Usage:

cshprod(io_err, n, m, goth, x, y, nnz_vector, index_nz_vector, vector,

nnzresult, indexnz_result, result)

  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • goth: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • y: [IN] Vector{Cdouble}
  • nnz_vector: [IN] Vector{Cint}
  • indexnzvector: [IN] Vector{Cint}
  • vector: [IN] Vector{Cdouble}
  • nnz_result: [OUT] Vector{Cint}
  • indexnzresult: [OUT] Vector{Cint}
  • result: [OUT] Vector{Cdouble}

Notice that vector and result should have allocated dimension of n.

source
CUTEst.csjprodMethod

csjprod

The csjprod subroutine forms the product of a sparse vector with the Jacobian matrix, or with its transpose, of the constraint functions of the problem decoded from a SIF file by the script sifdecoder evaluated at the point X. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_csjprod

Usage:

csjprod(io_err, n, m, gotj, jtrans, x, nnz_vector, index_nz_vector, vector,

lvector, nnzresult, indexnz_result, result, lresult)

  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • m: [IN] Vector{Cint}
  • gotj: [IN] Vector{Cint}
  • jtrans: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • nnz_vector: [IN] Vector{Cint}
  • indexnzvector: [IN] Vector{Cint}
  • vector: [IN] Vector{Cdouble}
  • lvector: [IN] Vector{Cint}
  • nnz_result: [OUT] Vector{Cint}
  • indexnzresult: [OUT] Vector{Cint}
  • result: [OUT] Vector{Cdouble}
  • lresult: [IN] Vector{Cint}
source
CUTEst.cstatsMethod

cstats

cstats(io_err, nonlinear_variables_objective,

nonlinearvariablesconstraints, equalityconstraints, linearconstraints)

  • io_err: [OUT] Vector{Cint}
  • nonlinearvariablesobjective: [OUT] Vector{Cint}
  • nonlinearvariablesconstraints: [OUT] Vector{Cint}
  • equality_constraints: [OUT] Vector{Cint}
  • linear_constraints: [OUT] Vector{Cint}
source
CUTEst.cterminateMethod

cterminate

The uterminate subroutine deallocates all workspace arrays created since the last call to csetup.

For more information, run the shell command

man cutest_cterminate

Usage:

cterminate(io_err)
  • io_err: [OUT] Vector{Cint}
source
CUTEst.cvartypeMethod

cvartype

The cvartype subroutine determines the type (continuous, 0-1, integer) of each variable involved in the problem decoded from a SIF file by the script sifdecoder. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_cvartype

Usage:

cvartype(io_err, n, x_type)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • x_type: [OUT] Vector{Cint}
source
CUTEst.pnameMethod

pname

The pname subroutine obtains the name of the problem directly from the datafile OUTSDIF.d that was created by the script sifdecoder when decoding a SIF file. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_pname

Usage:

pname(io_err, input, pname)
  • io_err: [OUT] Vector{Cint}
  • input: [IN] Vector{Cint}
  • pname: [OUT] Vector{UInt8}
source
CUTEst.probnameMethod

probname

The probname subroutine obtains the name of the problem. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_probname

Usage:

probname(io_err, pname)
  • io_err: [OUT] Vector{Cint}
  • pname: [OUT] Vector{UInt8}

To get a useful name, use String(pname).

source
CUTEst.selectMethod
select(;min_var=1, max_var=Inf, min_con=0, max_con=Inf,
        objtype=*, contype=*,
        only_free_var=false, only_bnd_var=false,
        only_linear_con=false, only_nonlinear_con=false,
        only_equ_con=false, only_ineq_con=false,
        custom_filter=*)

Returns a subset of the CUTEst problems using the classification file classf.json. This file is export together with the package, so if you have an old CUTEst installation, it can lead to inconsistencies.

  • min_var and max_var set the number of variables in the problem;
  • min_con and max_con set the number of constraints in the problem

(e.g., use max_con=0 for unconstrained or min_con=1 for constrained)

  • only_* flags are self-explaining. Note that they appear in conflicting

pairs. Both can be false, but only one can be true.

  • objtype is the classification of the objective function according to the

MASTSIF classification file. It can be a number, a symbol, a string, or an array of those.

1, :none or "none" means there is no objective function;
2, :constant or "constant" means the objective function is a constant;
3, :linear or "linear" means the objective function is a linear functional;
4, :quadratic or "quadratic" means the objective function is quadratic;
5, :sum_of_squares or "sum_of_squares" means the objective function is a sum of squares
6, :other or "other" means the objective function is none of the above.
  • contype is the classification of the constraints according to the same MASTSIF classification file.

    1, :unc or "unc" means there are no constraints at all; 2, :fixedvars or "fixedvars" means the only constraints are fixed variables; 3, :bounds or "bounds" means the only constraints are bounded variables; 4, :network or "network" means the constraints represent the adjacency matrix of a (linear) network; 5, :linear or "linear" means the constraints are linear; 6, :quadratic or "quadratic" means the constraints are quadratic; 7, :other or "other" means the constraints are more general.

  • custom_filter is a function to be applied to the problem data, which is a dict with the following fields:

    "objtype" - String one of the above objective function types "contype" - String one of the above constraint types "regular" - Bool whether the problem is regular or not "derivativeorder" - Int order of the highest derivative available "origin" - String origin of the problem: "academic", "modelling" or "real" "hasintervalvar" - Bool whether it has interval variables "variables" - Dict with the following fields "canchoose" - Bool whether you can change the number of variables via parameters "number" - Int the number of variables (if can_choose, the default) "fixed" - Int the number of fixed variables "free" - Int the number of free variables "boundedbelow" - Int the number of variables bounded only from below "boundedabove" - Int the number of variables bounded only from above "boundedboth" - Int the number of variables bounded from below and above "constraints" - Dict with the following fields "canchoose" - Bool whether you can change the number of constraints via parameters "number" - Int the number of constraints (if can_choose, the default) "equality" - Int the number of equality constraints "ineqbelow" - Int the number of inequalities of the form c(x) ≧ cl "ineqabove" - Int the number of inequalities of the form c(x) ≦ cu "ineq_both" - Int the number of inequalities of the form cl ≦ c(x) ≦ cu "linear" - Int the number of linear constraints "nonlinear" - Int the number of nonlinear constraints

For instance, if you'd like to choose only problems with fixed number of variables, you can pass

custom_filter=x->x["variables"]["can_choose"]==false
source
CUTEst.set_mastsifMethod
set_mastsif()

Set the MASTSIF environment variable to point to the main SIF collection.

source
CUTEst.sifdecoderMethod

Decode problem and build shared library.

Optional arguments are passed directly to the SIF decoder. Example: sifdecoder("DIXMAANJ", "-param", "M=30").

source
CUTEst.ubandhMethod

ubandh

The ubandh subroutine extracts the elements which lie within a band of given semi-bandwidth out of the Hessian matrix of the objective function of the problem decoded from a SIF file by the script sifdecoder at the point X. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to the simple bounds xl≤x≤xu. The objective function is group- partially separable.

For more information, run the shell command

man cutest_ubandh

Usage:

ubandh(io_err, n, x, semibandwidth, h_band, lbandh, max_semibandwidth)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • semibandwidth: [IN] Vector{Cint}
  • h_band: [OUT] Array{Cdouble, 2}
  • lbandh: [IN] Vector{Cint}
  • max_semibandwidth: [OUT] Vector{Cint}
source
CUTEst.udhMethod

udh

The udh subroutine evaluates the Hessian matrix of the objective function of the problem decoded from a SIF file by the script sifdecoder at the point X. This Hessian matrix is stored as a dense matrix. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to the simple bounds xl≤x≤xu. The objective function is group-partially separable.

For more information, run the shell command

man cutest_udh

Usage:

udh(io_err, n, x, lh1, h)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • lh1: [IN] Vector{Cint}
  • h: [OUT] Array{Cdouble, 2}
source
CUTEst.udimenMethod

udimen

The udimen subroutine discovers how many variables are involved in the problem decoded from a SIF file by the script sifdecoder. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to the simple bounds xl≤x≤xu. The objective function is group-partially separable.

For more information, run the shell command

man cutest_udimen

Usage:

udimen(io_err, input, n)
  • io_err: [OUT] Vector{Cint}
  • input: [IN] Vector{Cint}
  • n: [OUT] Vector{Cint}
source
CUTEst.udimseMethod

udimse

The udimse subroutine determine the number of nonzeros required to store the Hessian matrix of the objective function of the problem decoded from a SIF file by the script sifdecoder at the point X. This Hessian matrix is stored as a sparse matrix in finite element format H=eΣ1He, where each square symmetric element H_i involves a small subset of the rows of the Hessian matrix. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to the simple bounds xl≤x≤xu. The objective function is group-partially separable.

For more information, run the shell command

man cutest_udimse

Usage:

udimse(io_err, ne, he_val_ne, he_row_ne)
  • io_err: [OUT] Vector{Cint}
  • ne: [OUT] Vector{Cint}
  • hevalne: [OUT] Vector{Cint}
  • herowne: [OUT] Vector{Cint}
source
CUTEst.udimshMethod

udimsh

The udimsh subroutine determine the number of nonzeros required to store the Hessian matrix of the objective function of the problem decoded from a SIF file by the script sifdecoder at the point X. This Hessian matrix is stored as a sparse matrix in coordinate format. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to the simple bounds xl≤x≤xu. The objective function is group-partially separable.

For more information, run the shell command

man cutest_udimsh

Usage:

udimsh(io_err, nnzh)
  • io_err: [OUT] Vector{Cint}
  • nnzh: [OUT] Vector{Cint}
source
CUTEst.uehMethod

ueh

The ueh subroutine evaluates the Hessian matrix of the objective function of the problem decoded from a SIF file by the script sifdecoder at the point X. This Hessian matrix is stored as a sparse matrix in finite element format H=eΣ1He, where each square symmetric element He involves a small subset of the rows of the Hessian matrix. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to the simple bounds xl≤x≤xu. The objective function is group-partially separable.

For more information, run the shell command

man cutest_ueh

Usage:

ueh(io_err, n, x, ne, lhe_ptr, he_row_ptr, he_val_ptr, lhe_row, he_row,

lheval, heval, byrows)

  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • ne: [OUT] Vector{Cint}
  • lhe_ptr: [IN] Vector{Cint}
  • herowptr: [OUT] Vector{Cint}
  • hevalptr: [OUT] Vector{Cint}
  • lhe_row: [IN] Vector{Cint}
  • he_row: [OUT] Vector{Cint}
  • lhe_val: [IN] Vector{Cint}
  • he_val: [OUT] Vector{Cdouble}
  • byrows: [IN] Vector{Cint}
source
CUTEst.ufnMethod

ufn

The ufn subroutine evaluates the value of the objective function of the problem decoded from a SIF file by the script sifdecoder at the point X. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to the simple bounds xl≤x≤xu. The objective function is group-partially separable.

For more information, run the shell command

man cutest_ufn

Usage:

ufn(io_err, n, x, f)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • f: [OUT] Vector{Cdouble}
source
CUTEst.ugrMethod

ugr

The ugr subroutine evaluates the gradient of the objective function of the problem decoded from a SIF file by the script sifdecoder at the point X. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to the simple bounds xl≤x≤xu. The objective function is group-partially separable.

For more information, run the shell command

man cutest_ugr

Usage:

ugr(io_err, n, x, g)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • g: [OUT] Vector{Cdouble}
source
CUTEst.ugrdhMethod

ugrdh

The ugrdh subroutine evaluates the gradient and Hessian matrix of the objective function of the problem decoded from a SIF file by the script sifdecoder at the point X. This Hessian matrix is stored as a dense matrix. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to the simple bounds xl≤x≤xu. The objective function is group-partially separable.

For more information, run the shell command

man cutest_ugrdh

Usage:

ugrdh(io_err, n, x, g, lh1, h)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • g: [OUT] Vector{Cdouble}
  • lh1: [IN] Vector{Cint}
  • h: [OUT] Array{Cdouble, 2}
source
CUTEst.ugrehMethod

ugreh

The ugreh subroutine evaluates the gradient and Hessian matrix of the objective function of the problem decoded from a SIF file by the script sifdecoder at the point X. This Hessian matrix is stored as a sparse matrix in finite element format H=eΣ1He, where each square symmetric element H sub e involves a small subset of the rows of the Hessian matrix. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to the simple bounds xl≤x≤xu. The objective function is group-partially separable.

For more information, run the shell command

man cutest_ugreh

Usage:

ugreh(io_err, n, x, g, ne, lhe_ptr, he_row_ptr, he_val_ptr, lhe_row, he_row,

lheval, heval, byrows)

  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • g: [OUT] Vector{Cdouble}
  • ne: [OUT] Vector{Cint}
  • lhe_ptr: [IN] Vector{Cint}
  • herowptr: [OUT] Vector{Cint}
  • hevalptr: [OUT] Vector{Cint}
  • lhe_row: [IN] Vector{Cint}
  • he_row: [OUT] Vector{Cint}
  • lhe_val: [IN] Vector{Cint}
  • he_val: [OUT] Vector{Cdouble}
  • byrows: [IN] Vector{Cint}
source
CUTEst.ugrshMethod

ugrsh

The ugrsh subroutine evaluates the gradient and Hessian matrix of the objective function of the problem decoded from a SIF file by the script sifdecoder at the point X. This Hessian matrix is stored as a sparse matrix in coordinate format. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to the simple bounds xl≤x≤xu. The objective function is group- partially separable.

For more information, run the shell command

man cutest_ugrsh

Usage:

ugrsh(io_err, n, x, g, nnzh, lh, h_val, h_row, h_col)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • g: [OUT] Vector{Cdouble}
  • nnzh: [OUT] Vector{Cint}
  • lh: [IN] Vector{Cint}
  • h_val: [OUT] Vector{Cdouble}
  • h_row: [OUT] Vector{Cint}
  • h_col: [OUT] Vector{Cint}
source
CUTEst.uhprodMethod

uhprod

The uhprod subroutine forms the product of a vector with the Hessian matrix of the objective function of the problem decoded from a SIF file by the script sifdecoder at the point X. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to the simple bounds xl≤x≤xu. The objective function is group-partially separable.

For more information, run the shell command

man cutest_uhprod

Usage:

uhprod(io_err, n, goth, x, vector, result)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • goth: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • vector: [IN] Vector{Cdouble}
  • result: [OUT] Vector{Cdouble}
source
CUTEst.unamesMethod

unames

The unames subroutine obtains the names of the problem and its variables. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to the simple bounds xl≤x≤xu. The objective function is group-partially separable.

For more information, run the shell command

man cutest_unames

Usage:

unames(io_err, n, pname, vname)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • pname: [OUT] Vector{UInt8}
  • vname: [OUT] Vector{UInt8}

To get useful names, use String(x) where x can be pname or vname[:,i].

source
CUTEst.uofgMethod

uofg

The uofg subroutine evaluates the value of the objective function of the problem decoded from a SIF file by the script sifdecoder at the point X, and possibly its gradient. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to the simple bounds xl≤x≤xu. The objective function is group- partially separable.

For more information, run the shell command

man cutest_uofg

Usage:

uofg(io_err, n, x, f, g, grad)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • f: [OUT] Vector{Cdouble}
  • g: [OUT] Vector{Cdouble}
  • grad: [IN] Vector{Cint}
source
CUTEst.ureportMethod

ureport

The ureport subroutine obtains statistics concerning function evaluation and CPU time used for unconstrained or bound-constrained optimization in a standardized format. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to the simple bounds xl≤x≤xu. The objective function is group- partially separable.

For more information, run the shell command

man cutest_ureport

Usage:

ureport(io_err, calls, time)
  • io_err: [OUT] Vector{Cint}
  • calls: [OUT] Vector{Cdouble}
  • time: [OUT] Vector{Cdouble}
source
CUTEst.usetupMethod

usetup

The usetup subroutine sets up the correct data structures for subsequent computations in the case where the only possible constraints are bound constraints. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to the simple bounds xl≤x≤xu. The objective function is group- partially separable.

For more information, run the shell command

man cutest_usetup

Usage:

usetup(io_err, input, out, io_buffer, n, x, x_l, x_u)
  • io_err: [OUT] Vector{Cint}
  • input: [IN] Vector{Cint}
  • out: [IN] Vector{Cint}
  • io_buffer: [IN] Vector{Cint}
  • n: [IN] Vector{Cint}
  • x: [OUT] Vector{Cdouble}
  • x_l: [OUT] Vector{Cdouble}
  • x_u: [OUT] Vector{Cdouble}
source
CUTEst.ushMethod

ush

The ush subroutine evaluates the Hessian matrix of the objective function of the problem decoded from a SIF file by the script sifdecoder at the point X. This Hessian matrix is stored as a sparse matrix in coordinate format. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to the simple bounds xl≤x≤xu. The objective function is group- partially separable.

For more information, run the shell command

man cutest_ush

Usage:

ush(io_err, n, x, nnzh, lh, h_val, h_row, h_col)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • nnzh: [OUT] Vector{Cint}
  • lh: [IN] Vector{Cint}
  • h_val: [OUT] Vector{Cdouble}
  • h_row: [OUT] Vector{Cint}
  • h_col: [OUT] Vector{Cint}
source
CUTEst.ushpMethod

ushp

The ushp subroutine evaluates the sparsity pattern of the Hessian matrix of the objective function of the problem, decoded from a SIF file by the script sifdecoder, in coordinate format. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to the simple bounds xl≤x≤xu. The objective function is group-partially separable.

For more information, run the shell command

man cutest_ushp

Usage:

ushp(io_err, n, nnzh, lh, h_row, h_col)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • nnzh: [OUT] Vector{Cint}
  • lh: [IN] Vector{Cint}
  • h_row: [OUT] Vector{Cint}
  • h_col: [OUT] Vector{Cint}
source
CUTEst.ushprodMethod

ushprod

The ushprod subroutine forms the product of a sparse vector with the Hessian matrix of the objective function of the problem decoded from a SIF file by the script sifdecoder at the point X. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to the simple bounds xl≤x≤xu. The objective function is group-partially separable.

For more information, run the shell command

man cutest_ushprod

Usage:

ushprod(io_err, n, goth, x, nnz_vector, index_nz_vector, vector, nnz_result,

indexnzresult, result)

  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • goth: [IN] Vector{Cint}
  • x: [IN] Vector{Cdouble}
  • nnz_vector: [IN] Vector{Cint}
  • indexnzvector: [IN] Vector{Cint}
  • vector: [IN] Vector{Cdouble}
  • nnz_result: [OUT] Vector{Cint}
  • indexnzresult: [OUT] Vector{Cint}
  • result: [OUT] Vector{Cdouble}

Notice that vector and result should have allocated dimension of n.

source
CUTEst.uterminateMethod

uterminate

The uterminate subroutine deallocates all workspace arrays created since the last call to usetup.

For more information, run the shell command

man cutest_uterminate

Usage:

uterminate(io_err)
  • io_err: [OUT] Vector{Cint}
source
CUTEst.uvartypeMethod

uvartype

The uvartype subroutine determines the type (continuous, 0-1, integer) of each variable involved in the problem decoded from a SIF file by the script sifdecoder. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to the simple bounds xl≤x≤xu. The objective function is group-partially separable.

For more information, run the shell command

man cutest_uvartype

Usage:

uvartype(io_err, n, x_type)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • x_type: [OUT] Vector{Cint}
source
CUTEst.varnamesMethod

varnames

The varnames subroutine obtains the names of the problem variables. The problem under consideration is to minimize or maximize an objective function f(x) over all x ∈ Rn subject to general equations ci(x)=0, (i ∈ 1,...,mE), general inequalities ci(x)≤ci(x)≤ci(x), (i ∈ mE+1,...,m), and simple bounds xl≤x≤xu. The objective function is group-partially separable and all constraint functions are partially separable.

For more information, run the shell command

man cutest_varnames

Usage:

varnames(io_err, n, vname)
  • io_err: [OUT] Vector{Cint}
  • n: [IN] Vector{Cint}
  • vname: [OUT] Vector{UInt8}

To get useful names, use String(vname[:, i]).

source