Working with CUTEst directly

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}

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}

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

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}

cishp(T, libsif, status, n, iprob, nnzh, lh, irnh, icnh)

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.

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}

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}

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}

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}

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}

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}

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}

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}

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}

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}

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}

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}

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}

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}

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}

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}

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}

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}

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}

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}

uterminate(T, libsif, status)

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

• status: [OUT] Vector{Cint}

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}

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}

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}

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}

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}

fclose(T, libsif, funit, status)

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}

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}

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}

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}

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}

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}

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}

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}

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}

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}

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}

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}

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}

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

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}

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}

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}

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}

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}

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}

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

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

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}

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}

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}

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}

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}

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.

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}

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

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}

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}

chjprod(T, libsif, status, m, n, x, mode, nnz, j_val, j_col)

The chjprod subroutine evaluates the product of the Jacobian of the constraints with a vector. This is useful when computing first-order sensitivity or constraint violation directions in constrained optimization.

The Jacobian J(x) = [∇c₁(x); ∇c₂(x); ... ; ∇cₘ(x)] is multiplied by a vector v, and the result is returned in sparse format.

• status: [OUT] Vector{Cint} — status code after execution
• m: [IN] Vector{Cint} — number of constraints
• n: [IN] Vector{Cint} — number of variables
• x: [IN] Vector{T} — point of evaluation x ∈ ℝⁿ
• mode: [IN] Vector{Cint} — evaluation flags or configuration
• nnz: [OUT] Vector{Cint} — number of nonzero entries in output
• j_val: [OUT] Vector{T} — nonzero values of Jacobian-vector product
• j_col: [OUT] Vector{Cint} — column indices of nonzero entries

The output vectors j_val and j_col must be preallocated and will contain the result of J(x) * v in sparse format.

cohprods(T, libsif, status, m, x, lambda, mode, nnz, h_val, h_col)

The cohprods subroutine evaluates the linear combination of the Hessians of the constraint functions, each weighted by its corresponding Lagrange multiplier.

Mathematically, it computes:

H_λ(x) = ∑ λᵢ ∇²cᵢ(x)

where cᵢ(x) are the constraints, and λᵢ are the Lagrange multipliers. This matrix is essential when forming the Hessian of the Lagrangian L(x,λ) = f(x) + λᵗ c(x).

This call returns the nonzero structure of H_λ(x) in sparse format.

• status: [OUT] Vector{Cint} — status code
• m: [IN] Vector{Cint} — number of constraints
• x: [IN] Vector{T} — point of evaluation x ∈ ℝⁿ
• lambda: [IN] Vector{T} — vector of Lagrange multipliers (length m)
• mode: [IN] Vector{Cint} — evaluation flags
• nnz: [OUT] Vector{Cint} — number of nonzeros in result
• hval: [OUT] Vector{T} — values of nonzero entries in Hλ(x)
• h_col: [OUT] Vector{Cint} — corresponding column indices

This subroutine is crucial for second-order constrained optimization and must be called with properly initialized lambda.

chsprod(T, libsif, status, n, x, mode, nnz, h_val, h_col)

The chsprod subroutine evaluates the product of the constraint Hessian with a direction vector, for problems decoded from a SIF file using libsif. This is used for computing second-order information about the constraints during optimization.

The constraint Hessian is defined as:

H_c(x) := ∑ λᵢ ∇²cᵢ(x)

where each cᵢ(x) is a constraint function and λᵢ are multipliers. Given a direction vector v, the product H_c(x)v is computed efficiently without forming the full matrix.

This routine returns the result in sparse format (value + column index).

• status: [OUT] Vector{Cint} — status code after execution
• n: [IN] Vector{Cint} — number of variables
• x: [IN] Vector{T} — evaluation point x ∈ ℝⁿ
• mode: [IN] Vector{Cint} — operation mode (e.g., evaluation flags)
• nnz: [OUT] Vector{Cint} — number of nonzeros in result
• h_val: [OUT] Vector{T} — nonzero values of Hessian-vector product
• h_col: [OUT] Vector{Cint} — corresponding column indices

The vectors h_val and h_col must be preallocated. Output is given in sparse format (compressed column or row depending on solver).

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}

cterminate(T, libsif, status)

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

• status: [OUT] Vector{Cint}

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}

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}

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

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}

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

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}

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

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}

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}

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