Working with CUTEst directly

When working with CUTEst, we created a core interface, which is essentially an interface for the core CUTEst functions. The core interface is implemented in core_interface.jl. However, you probably won't want to use this directly because the NLPModels interface is much more user-friendly and just as effective. For more information, see its tutorial.

CUTEst.jl calls Fortran routines from CUTEst via Julia wrappers in libcutest.jl.

For each of these routines, we dropped the prefix cutest_ and the suffixes _s_, _, and _q_. For example, the functions cutest_ufn_s_, cutest_ufn_, and cutest_ufn_q_ are all available as ufn. The ufn function takes an additional argument T in the first position, where T can be Float32, Float64, or Float128. This allows for a unified interface to the routines in single, double, and quadruple precision.

Only use these functions if you really know what you're doing.

If you want to use these functions, you should still decode the problem as an NLP by doing the following:

using CUTEst, Quadmath

# Float32, Float64 and Float128 are supported
T = Float64
nlp = CUTEstModel{T}("PROBLEM")
x = rand(T, nlp.meta.nvar)
f = Ref{T}()
CUTEst.ufn(T, nlp.libsif, nlp.status, nlp.nvar, x, f)
println(f[])

CUTEst.cjprod — Function

cjprod(T, libsif, status, n, m, gotj, jtrans, x, vector, lvector, result, lresult)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
gotj: [IN] Vector{Bool}
jtrans: [IN] Vector{Bool}
x: [IN] Vector{T}
vector: [IN] Vector{T}
lvector: [IN] Vector{Cint}
result: [OUT] Vector{T}
lresult: [IN] Vector{Cint}

CUTEst.ccfg — Function

ccfg(T, libsif, status, n, m, x, c, jtrans, lcjac1, lcjac2, cjac, grad)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
x: [IN] Vector{T}
c: [OUT] Vector{T}
jtrans: [IN] Vector{Bool}
lcjac1: [IN] Vector{Cint}
lcjac2: [IN] Vector{Cint}
cjac: [OUT] Matrix{T}
grad: [IN] Vector{Bool}

CUTEst.ccf — Function

ccf(T, libsif, status, n, m, x, c)

CUTEst.cish — Function

cish(T, libsif, status, n, x, iprob, nnzh, lh, h_val, h_row, h_col)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
x: [IN] Vector{T}
iprob: [IN] Vector{Cint}
nnzh: [OUT] Vector{Cint}
lh: [IN] Vector{Cint}
h_val: [OUT] Vector{T}
h_row: [OUT] Vector{Cint}
h_col: [OUT] Vector{Cint}

CUTEst.ushprod — Function

ushprod(T, libsif, status, n, goth, x, nnz_vector, index_nz_vector, vector, nnz_result, index_nz_result, result)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
goth: [IN] Vector{Bool}
x: [IN] Vector{T}
nnz_vector: [IN] Vector{Cint}
indexnzvector: [IN] Vector{Cint}
vector: [IN] Vector{T}
nnz_result: [OUT] Vector{Cint}
indexnzresult: [OUT] Vector{Cint}
result: [OUT] Vector{T}

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

CUTEst.cdimchp — Function

cdimchp(T, libsif, status, nnzchp)

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.

status: [OUT] Vector{Cint}
nnzchp: [OUT] Vector{Cint}

CUTEst.ureport — Function

ureport(T, libsif, status, calls, time)

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.

status: [OUT] Vector{Cint}
calls: [OUT] Vector{T}
time: [OUT] Vector{T}

CUTEst.chcprod — Function

chcprod(T, libsif, status, n, m, goth, x, y, vector, result)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
goth: [IN] Vector{Bool}
x: [IN] Vector{T}
y: [IN] Vector{T}
vector: [IN] Vector{T}
result: [OUT] Vector{T}

CUTEst.udimse — Function

udimse(T, libsif, status, ne, he_val_ne, he_row_ne)

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.

status: [OUT] Vector{Cint}
ne: [OUT] Vector{Cint}
hevalne: [OUT] Vector{Cint}
herowne: [OUT] Vector{Cint}

CUTEst.ubandh — Function

ubandh(T, libsif, status, n, x, semibandwidth, h_band, lbandh, max_semibandwidth)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
x: [IN] Vector{T}
semibandwidth: [IN] Vector{Cint}
h_band: [OUT] Matrix{T}
lbandh: [IN] Vector{Cint}
max_semibandwidth: [OUT] Vector{Cint}

CUTEst.csjp — Function

csjp(T, libsif, status, nnzj, lj, jvar, jcon)

The csjp subroutine evaluates the sparsity pattern of the Jacobian of the constraints for a problem decoded from a SIF file by the script sifdecoder.

status: [OUT] Vector{Cint}
nnzj: [OUT] Vector{Cint}
lj: [IN] Vector{Cint}
jvar: [OUT] Vector{Cint}
jcon: [OUT] Vector{Cint}

CUTEst.cgr — Function

cgr(T, libsif, status, n, m, x, y, grlagf, g, jtrans, lj1, lj2, j_val)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
x: [IN] Vector{T}
y: [IN] Vector{T}
grlagf: [IN] Vector{Bool}
g: [OUT] Vector{T}
jtrans: [IN] Vector{Bool}
lj1: [IN] Vector{Cint}
lj2: [IN] Vector{Cint}
j_val: [OUT] Matrix{T}

CUTEst.ufn — Function

ufn(T, libsif, status, n, x, f)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
x: [IN] Vector{T}
f: [OUT] Vector{T}

CUTEst.csgrp — Function

csgrp(T, libsif, status, n, nnzj, lj, j_var, j_fun)

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.

status: [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.cshc — Function

cshc(T, libsif, status, n, m, x, y, nnzh, lh, h_val, h_row, h_col)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
x: [IN] Vector{T}
y: [IN] Vector{T}
nnzh: [OUT] Vector{Cint}
lh: [IN] Vector{Cint}
h_val: [OUT] Vector{T}
h_row: [OUT] Vector{Cint}
h_col: [OUT] Vector{Cint}

CUTEst.cdimsj — Function

cdimsj(T, libsif, status, nnzj)

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.

status: [OUT] Vector{Cint}
nnzj: [OUT] Vector{Cint}

CUTEst.cfn — Function

cfn(T, libsif, status, n, m, x, f, c)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
x: [IN] Vector{T}
f: [OUT] Vector{T}
c: [OUT] Vector{T}

CUTEst.cofg — Function

cofg(T, libsif, status, n, x, f, g, grad)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
x: [IN] Vector{T}
f: [OUT] Vector{T}
g: [OUT] Vector{T}
grad: [IN] Vector{Bool}

CUTEst.cofsg — Function

cofsg(T, libsif, status, n, x, f, nnzg, lg, g_val, g_var, grad)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
x: [IN] Vector{T}
f: [OUT] Vector{T}
nnzg: [OUT] Vector{Cint}
lg: [IN] Vector{Cint}
g_val: [OUT] Vector{T}
g_var: [OUT] Vector{Cint}
grad: [IN] Vector{Bool}

CUTEst.ceh — Function

ceh(T, libsif, status, n, m, x, y, ne, lhe_ptr, he_row_ptr, he_val_ptr, lhe_row, he_row, lhe_val, he_val, byrows)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
x: [IN] Vector{T}
y: [IN] Vector{T}
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{T}
byrows: [IN] Vector{Cint}

CUTEst.cdimsh — Function

cdimsh(T, libsif, status, nnzh)

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.

status: [OUT] Vector{Cint}
nnzh: [OUT] Vector{Cint}

CUTEst.ugr — Function

ugr(T, libsif, status, n, x, g)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
x: [IN] Vector{T}
g: [OUT] Vector{T}

CUTEst.cshcprod — Function

cshcprod(T, libsif, status, n, m, goth, x, y, nnz_vector, index_nz_vector, vector, nnz_result, index_nz_result, result)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
goth: [IN] Vector{Bool}
x: [IN] Vector{T}
y: [IN] Vector{T}
nnz_vector: [IN] Vector{Cint}
indexnzvector: [IN] Vector{Cint}
vector: [IN] Vector{T}
nnz_result: [OUT] Vector{Cint}
indexnzresult: [OUT] Vector{Cint}
result: [OUT] Vector{T}

CUTEst.uhprod — Function

uhprod(T, libsif, status, n, goth, x, vector, result)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
goth: [IN] Vector{Bool}
x: [IN] Vector{T}
vector: [IN] Vector{T}
result: [OUT] Vector{T}

CUTEst.csgreh — Function

csgreh(T, libsif, status, n, m, x, y, grlagf, nnzj, lj, j_val, j_var, j_fun, ne, lhe_ptr, he_row_ptr, he_val_ptr, lhe_row, he_row, lhe_val, he_val, byrows)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
x: [IN] Vector{T}
y: [IN] Vector{T}
grlagf: [IN] Vector{Bool}
nnzj: [OUT] Vector{Cint}
lj: [IN] Vector{Cint}
j_val: [OUT] Vector{T}
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{T}
byrows: [IN] Vector{Bool}

CUTEst.uterminate — Function

uterminate(T, libsif, status)

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

status: [OUT] Vector{Cint}

CUTEst.ugreh — Function

ugreh(T, libsif, status, n, x, g, ne, lhe_ptr, he_row_ptr, he_val_ptr, lhe_row, he_row, lhe_val, he_val, byrows)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
x: [IN] Vector{T}
g: [OUT] Vector{T}
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{T}
byrows: [IN] Vector{Bool}

CUTEst.cigr — Function

cigr(T, libsif, status, n, iprob, x, g_val)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
iprob: [IN] Vector{Cint}
x: [IN] Vector{T}
g_val: [OUT] Vector{T}

CUTEst.clfg — Function

clfg(T, libsif, status, n, m, x, y, f, g, grad)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
x: [IN] Vector{T}
y: [IN] Vector{T}
f: [OUT] Vector{T}
g: [OUT] Vector{T}
grad: [IN] Vector{Bool}

CUTEst.ugrdh — Function

ugrdh(T, libsif, status, n, x, g, lh1, h)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
x: [IN] Vector{T}
g: [OUT] Vector{T}
lh1: [IN] Vector{Cint}
h: [OUT] Matrix{T}

CUTEst.cdhc — Function

cdhc(T, libsif, status, n, m, x, y, lh1, h_val)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
x: [IN] Vector{T}
y: [IN] Vector{T}
lh1: [IN] Vector{Cint}
h_val: [OUT] Matrix{T}

CUTEst.fclose — Function

fclose(T, libsif, funit, status)

CUTEst.csetup — Function

csetup(libsif, status, input, out, io_buffer, n, m, x, x_l, x_u, y, c_l, c_u, equatn, linear, e_order, l_order, v_order)

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.

status: [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{T}
x_l: [OUT] Vector{T}
x_u: [OUT] Vector{T}
y: [OUT] Vector{T}
c_l: [OUT] Vector{T}
c_u: [OUT] Vector{T}
equatn: [OUT] Vector{Bool}
linear: [OUT] Vector{Bool}
e_order: [IN] Vector{Cint}
l_order: [IN] Vector{Cint}
v_order: [IN] Vector{Cint}

CUTEst.ccifg — Function

ccifg(T, libsif, status, n, icon, x, ci, gci, grad)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
icon: [IN] Vector{Cint}
x: [IN] Vector{T}
ci: [OUT] Vector{T}
gci: [OUT] Vector{T}
grad: [IN] Vector{Bool}

CUTEst.cvartype — Function

cvartype(T, libsif, status, n, x_type)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
x_type: [OUT] Vector{Cint}

CUTEst.udimsh — Function

udimsh(T, libsif, status, nnzh)

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.

status: [OUT] Vector{Cint}
nnzh: [OUT] Vector{Cint}

CUTEst.csjprod — Function

csjprod(T, libsif, status, n, m, gotj, jtrans, x, nnz_vector, index_nz_vector, vector, lvector, nnz_result, index_nz_result, result, lresult)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
gotj: [IN] Vector{Bool}
jtrans: [IN] Vector{Bool}
x: [IN] Vector{T}
nnz_vector: [IN] Vector{Cint}
indexnzvector: [IN] Vector{Cint}
vector: [IN] Vector{T}
lvector: [IN] Vector{Cint}
nnz_result: [OUT] Vector{Cint}
indexnzresult: [OUT] Vector{Cint}
result: [OUT] Vector{T}
lresult: [IN] Vector{Cint}

CUTEst.cgrdh — Function

cgrdh(T, libsif, status, n, m, x, y, grlagf, g, jtrans, lj1, lj2, j_val, lh1, h_val)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
x: [IN] Vector{T}
y: [IN] Vector{T}
grlagf: [IN] Vector{Bool}
g: [OUT] Vector{T}
jtrans: [IN] Vector{Bool}
lj1: [IN] Vector{Cint}
lj2: [IN] Vector{Cint}
j_val: [OUT] Matrix{T}
lh1: [IN] Vector{Cint}
h_val: [OUT] Matrix{T}

CUTEst.cdh — Function

cdh(T, libsif, status, n, m, x, y, lh1, h_val)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
x: [IN] Vector{T}
y: [IN] Vector{T}
lh1: [IN] Vector{Cint}
h_val: [OUT] Matrix{T}

CUTEst.ush — Function

ush(T, libsif, status, n, x, nnzh, lh, h_val, h_row, h_col)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
x: [IN] Vector{T}
nnzh: [OUT] Vector{Cint}
lh: [IN] Vector{Cint}
h_val: [OUT] Vector{T}
h_row: [OUT] Vector{Cint}
h_col: [OUT] Vector{Cint}

CUTEst.csh — Function

csh(T, libsif, status, n, m, x, y, nnzh, lh, h_val, h_row, h_col)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
x: [IN] Vector{T}
y: [IN] Vector{T}
nnzh: [OUT] Vector{Cint}
lh: [IN] Vector{Cint}
h_val: [OUT] Vector{T}
h_row: [OUT] Vector{Cint}
h_col: [OUT] Vector{Cint}

CUTEst.ueh — Function

ueh(T, libsif, status, n, x, ne, lhe_ptr, he_row_ptr, he_val_ptr, lhe_row, he_row, lhe_val, he_val, byrows)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
x: [IN] Vector{T}
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{T}
byrows: [IN] Vector{Bool}

CUTEst.cchprods — Function

cchprods(T, libsif, status, n, m, goth, x, vector, lchp, chp_val, chp_ind, chp_ptr)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
goth: [IN] Vector{Bool}
x: [IN] Vector{T}
vector: [IN] Vector{T}
lchp: [IN] Vector{Cint}
chp_val: [OUT] Vector{T}
chp_ind: [IN] Vector{Cint}
chp_ptr: [IN] Vector{Cint}

CUTEst.ccifsg — Function

ccifsg(T, libsif, status, n, icon, x, ci, nnzgci, lgci, gci_val, gci_var, grad)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
icon: [IN] Vector{Cint}
x: [IN] Vector{T}
ci: [OUT] Vector{T}
nnzgci: [OUT] Vector{Cint}
lgci: [IN] Vector{Cint}
gci_val: [OUT] Vector{T}
gci_var: [OUT] Vector{Cint}
grad: [IN] Vector{Bool}

CUTEst.uofg — Function

uofg(T, libsif, status, n, x, f, g, grad)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
x: [IN] Vector{T}
f: [OUT] Vector{T}
g: [OUT] Vector{T}
grad: [IN] Vector{Bool}

CUTEst.connames — Function

connames(T, libsif, status, m, cname)

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.

status: [OUT] Vector{Cint}
m: [IN] Vector{Cint}
cname: [OUT] Vector{Cchar}

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

CUTEst.cisgr — Function

cisgr(T, libsif, status, n, iprod, x, nnzg, lg, g_val, g_var)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
iprob: [IN] Vector{Cint}
x: [IN] Vector{T}
nnzg: [OUT] Vector{Cint}
lg: [IN] Vector{Cint}
g_val: [OUT] Vector{T}
g_var: [OUT] Vector{Cint}

CUTEst.udh — Function

udh(T, libsif, status, n, x, lh1, h)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
x: [IN] Vector{T}
lh1: [IN] Vector{Cint}
h: [OUT] Matrix{T}

CUTEst.cdimse — Function

cdimse(T, libsif, status, ne, he_val_ne, he_row_ne)

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.

status: [OUT] Vector{Cint}
ne: [OUT] Vector{Cint}
hevalne: [OUT] Vector{Cint}
herowne: [OUT] Vector{Cint}

CUTEst.ushp — Function

ushp(T, libsif, status, n, nnzh, lh, h_row, h_col)

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.

status: [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.creport — Function

creport(T, libsif, status, calls, time)

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.

status: [OUT] Vector{Cint}
calls: [OUT] Vector{T}
time: [OUT] Vector{T}

CUTEst.cshp — Function

cshp(T, libsif, status, n, nnzh, lh, h_row, h_col)

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.

status: [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.probname — Function

probname(T, libsif, status, pname)

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.

status: [OUT] Vector{Cint}
pname: [OUT] Vector{Cchar}

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

CUTEst.unames — Function

unames(T, libsif, status, n, pname, vname)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
pname: [OUT] Vector{Cchar}
vname: [OUT] Vector{Cchar}

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

CUTEst.cidh — Function

cidh(T, libsif, status, n, x, iprob, lh1, h)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
x: [IN] Vector{T}
iprob: [IN] Vector{Cint}
lh1: [IN] Vector{Cint}
h: [OUT] Matrix{T}

CUTEst.csgr — Function

csgr(T, libsif, status, n, m, x, y, grlagf, nnzj, lj, j_val, j_var, j_fun)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
x: [IN] Vector{T}
y: [IN] Vector{T}
grlagf: [IN] Vector{Bool}
nnzj: [OUT] Vector{Cint}
lj: [IN] Vector{Cint}
j_val: [OUT] Vector{T}
j_var: [OUT] Vector{Cint}
j_fun: [OUT] Vector{Cint}

CUTEst.usetup — Function

usetup(T, libsif, status, input, out, io_buffer, n, x, x_l, x_u)

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.

status: [OUT] Vector{Cint}
input: [IN] Vector{Cint}
out: [IN] Vector{Cint}
io_buffer: [IN] Vector{Cint}
n: [IN] Vector{Cint}
x: [OUT] Vector{T}
x_l: [OUT] Vector{T}
x_u: [OUT] Vector{T}

CUTEst.csgrsh — Function

csgrsh(T, libsif, status, n, m, x, y, grlagf, nnzj, lj, j_val, j_var, j_fun, nnzh, lh, h_val, h_row, h_col)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
x: [IN] Vector{T}
y: [IN] Vector{T}
grlagf: [IN] Vector{Bool}
nnzj: [OUT] Vector{Cint}
lj: [IN] Vector{Cint}
j_val: [OUT] Vector{T}
j_var: [OUT] Vector{Cint}
j_fun: [OUT] Vector{Cint}
nnzh: [OUT] Vector{Cint}
lh: [IN] Vector{Cint}
h_val: [OUT] Vector{T}
h_row: [OUT] Vector{Cint}
h_col: [OUT] Vector{Cint}

CUTEst.cdimen — Function

cdimen(T, libsif, status, input, n, m)

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.

status: [OUT] Vector{Cint}
input: [IN] Vector{Cint}
n: [OUT] Vector{Cint}
m: [OUT] Vector{Cint}

CUTEst.cshprod — Function

cshprod(T, libsif, status, n, m, goth, x, y, nnz_vector, index_nz_vector, vector, nnz_result, index_nz_result, result)

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.

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

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

CUTEst.cchprodsp — Function

cchprodsp(T, libsif, status, m, lchp, chp_ind, chp_ptr)

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.

status: [OUT] Vector{Cint}
m: [IN] Vector{Cint}
lchp: [IN] Vector{Cint}
chp_ind: [IN] Vector{Cint}
chp_ptr: [IN] Vector{Cint}

CUTEst.cconst — Function

cconst(T, libsif, status, m, c)

CUTEst.udimen — Function

udimen(T, libsif, status, input, n)

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.

status: [OUT] Vector{Cint}
input: [IN] Vector{Cint}
n: [OUT] Vector{Cint}

CUTEst.pname — Function

pname(T, libsif, status, input, 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.

status: [OUT] Vector{Cint}
input: [IN] Vector{Cint}
pname: [OUT] Vector{Cchar}

CUTEst.chprod — Function

chprod(T, libsif, status, n, m, goth, x, y, vector, result)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
goth: [IN] Vector{Bool}
x: [IN] Vector{T}
y: [IN] Vector{T}
vector: [IN] Vector{T}
result: [OUT] Vector{T}

CUTEst.cterminate — Function

cterminate(T, libsif, status)

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

status: [OUT] Vector{Cint}

CUTEst.cifn — Function

cifn(T, libsif, status, n, iprob, x, f)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
iprob: [IN] Vector{Cint}
x: [IN] Vector{T}
f: [OUT] Vector{T}

CUTEst.cstats — Function

cstats(T, libsif, status, nonlinear_variables_objective, nonlinear_variables_constraints, equality_constraints, linear_constraints)

status: [OUT] Vector{Cint}
nonlinearvariablesobjective: [OUT] Vector{Cint}
nonlinearvariablesconstraints: [OUT] Vector{Cint}
equality_constraints: [OUT] Vector{Cint}
linear_constraints: [OUT] Vector{Cint}

CUTEst.cnames — Function

cnames(T, libsif, status, n, m, pname, vname, cname)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
pname: [OUT] Vector{Cchar}
vname: [OUT] Vector{Cchar}
cname: [OUT] Vector{Cchar}

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

CUTEst.ugrsh — Function

ugrsh(T, libsif, status, n, x, g, nnzh, lh, h_val, h_row, h_col)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
x: [IN] Vector{T}
g: [OUT] Vector{T}
nnzh: [OUT] Vector{Cint}
lh: [IN] Vector{Cint}
h_val: [OUT] Vector{T}
h_row: [OUT] Vector{Cint}
h_col: [OUT] Vector{Cint}

CUTEst.varnames — Function

varnames(T, libsif, status, n, vname)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
vname: [OUT] Vector{Cchar}

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

CUTEst.uvartype — Function

uvartype(T, libsif, status, n, x_type)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
x_type: [OUT] Vector{Cint}

CUTEst.fopen — Function

fopen(T, libsif, funit, outsdif, status)

CUTEst.csgrshp — Function

csgrshp(T, libsif, status, n, nnzj, lj, j_var, j_fun, nnzh, lh, h_row, h_col)

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.

status: [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.ccfsg — Function

ccfsg(T, libsif, status, n, m, x, c, nnzj, lj, j_val, j_var, j_fun, grad)

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.

status: [OUT] Vector{Cint}
n: [IN] Vector{Cint}
m: [IN] Vector{Cint}
x: [IN] Vector{T}
c: [OUT] Vector{T}
nnzj: [OUT] Vector{Cint}
lj: [IN] Vector{Cint}
j_val: [OUT] Vector{T}
j_var: [OUT] Vector{Cint}
j_fun: [OUT] Vector{Cint}
grad: [IN] Vector{Bool}

CUTEst.classification — Function

classification(T, libsif, status, funit, class)