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.

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}
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.

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}
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.

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}
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}
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.

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}
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.

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}
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.

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}
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.

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}
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.

man cutest_cdimchp

Usage:

cdimchp(io_err, nnzchp)
• io_err: [OUT] Vector{Cint}
• nnzchp: [OUT] Vector{Cint}
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.

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}
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.

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}
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.

man cutest_cdimsh

Usage:

cdimsh(io_err, nnzh)
• io_err: [OUT] Vector{Cint}
• nnzh: [OUT] Vector{Cint}
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.

man cutest_cdimsj

Usage:

cdimsj(io_err, nnzj)
• io_err: [OUT] Vector{Cint}
• nnzj: [OUT] Vector{Cint}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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].

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.

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}
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.

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}
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.

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]).

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}
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}
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}
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.

man cutest_creport

Usage:

creport(io_err, calls, time)
• io_err: [OUT] Vector{Cint}
• calls: [OUT] Vector{Cdouble}
• time: [OUT] Vector{Cdouble}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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.

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.

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}
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}
CUTEst.cterminateMethod

cterminate

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

man cutest_cterminate

Usage:

cterminate(io_err)
• io_err: [OUT] Vector{Cint}
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.

man cutest_cvartype

Usage:

cvartype(io_err, n, x_type)
• io_err: [OUT] Vector{Cint}
• n: [IN] Vector{Cint}
• x_type: [OUT] Vector{Cint}
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.

man cutest_pname

Usage:

pname(io_err, input, pname)
• io_err: [OUT] Vector{Cint}
• input: [IN] Vector{Cint}
• pname: [OUT] Vector{UInt8}
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.

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).

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;
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
CUTEst.set_mastsifMethod
set_mastsif()

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

CUTEst.sifdecoderMethod

Decode problem and build shared library.

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

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.

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}
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.

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}
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.

man cutest_udimen

Usage:

udimen(io_err, input, n)
• io_err: [OUT] Vector{Cint}
• input: [IN] Vector{Cint}
• n: [OUT] Vector{Cint}
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.

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}
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.

man cutest_udimsh

Usage:

udimsh(io_err, nnzh)
• io_err: [OUT] Vector{Cint}
• nnzh: [OUT] Vector{Cint}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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}
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.

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].

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.

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}
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.

man cutest_ureport

Usage:

ureport(io_err, calls, time)
• io_err: [OUT] Vector{Cint}
• calls: [OUT] Vector{Cdouble}
• time: [OUT] Vector{Cdouble}
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.

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}
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.

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}
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.

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}
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.

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.

CUTEst.uterminateMethod

uterminate

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

man cutest_uterminate

Usage:

uterminate(io_err)
• io_err: [OUT] Vector{Cint}
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.

man cutest_uvartype

Usage:

uvartype(io_err, n, x_type)
• io_err: [OUT] Vector{Cint}
• n: [IN] Vector{Cint}
• x_type: [OUT] Vector{Cint}
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.