API

API

NLPModels API

NLPModels.obj — Function.

f = obj(nlp, x)

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

NLPModels.grad — Function.

g = grad(nlp, x)

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

NLPModels.grad! — Function.

g = grad!(nlp, x, g)

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

NLPModels.cons — Function.

c = cons(nlp, x)

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

NLPModels.cons! — Function.

c = cons!(nlp, x, c)

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

NLPModels.jac_coord — Function.

No documentation found.

Binding NLPModels.jac_coord! does not exist.

NLPModels.jac — Function.

Jx = jac(nlp, x)

Evaluate $\nabla c(x)$, the constraint's Jacobian at x as a sparse matrix.

NLPModels.jprod — Function.

Jv = jprod(nlp, x, v)

Evaluate $\nabla c(x)v$, the Jacobian-vector product at x.

NLPModels.jprod! — Function.

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

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

NLPModels.jtprod — Function.

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

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

NLPModels.jtprod! — Function.

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

Evaluate $\nabla c(x)^Tv$, the transposed-Jacobian-vector product at x in place.

NLPModels.hess_coord — Function.

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

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

\[ \nabla^2L(x,y) = \sigma * \nabla^2 f(x) + \sum{i=1}^m yi\nabla^2 c_i(x), \]

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

NLPModels.hess — Function.

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

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

\[ \nabla^2L(x,y) = \sigma * \nabla^2 f(x) + \sum{i=1}^m yi\nabla^2 c_i(x), \]

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

NLPModels.hprod — Function.

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

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

\[ \nabla^2L(x,y) = \sigma * \nabla^2 f(x) + \sum{i=1}^m yi\nabla^2 c_i(x), \]

with σ = obj_weight.

NLPModels.hprod! — Function.

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

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

\[ \nabla^2L(x,y) = \sigma * \nabla^2 f(x) + \sum{i=1}^m yi\nabla^2 c_i(x), \]

with σ = obj_weight.

Extra Julian API

NLPModels.objgrad — Function.

f, g = objgrad(nlp, x)

Evaluate $f(x)$ and $\nabla f(x)$ at x.

NLPModels.objgrad! — Function.

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

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

NLPModels.objcons — Function.

f, c = objcons(nlp, x)

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

NLPModels.objcons! — Function.

f = objcons!(nlp, x, c)

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

CUTEst.cons_coord — Function.
cons_coord(nlp, x)

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

c, jrow, jcol, jval = cons_coord(nlp, x)
  • nlp: [IN] CUTEstModel
  • x: [IN] Array{Float64, 1}
  • c: [OUT] Array{Float64, 1}
  • jrow: [OUT] Array{Int32, 1}
  • jcol: [OUT] Array{Int32, 1}
  • jval: [OUT] Array{Float64, 1}
CUTEst.consjac — Function.
consjac(nlp, x)

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

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

Select tools

CUTEst.select — Method.

select(;minvar=1, maxvar=Inf, mincon=0, maxcon=Inf, objtype=, contype=, onlyfreevar=false, onlybndvar=false, onlylinearcon=false, onlynonlinearcon=false, onlyequcon=false, onlyineqcon=false, custom_filter=*)

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

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

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

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

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

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

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

1, :none or "none" means there is no objective function;
2, :constant or "constant" means the objective function is a constant;
3, :linear or "linear" means the objective function is a linear functional;
4, :quadratic or "quadratic" means the objective function is quadratic;
5, :sum_of_squares or "sum_of_squares" means the objective function is a sum of squares
6, :other or "other" means the objective function is none of the above.

  • contype is the classification of the constraints according to the same MASTSIF classification file.

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

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

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

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

custom_filter=x->x["variables"]["can_choose"]==false
CUTEst.create_class — Function.

create_class()

Creates the file classf.json, running each problem in $MASTSIF/CLASSF.DB and extracting the necessary information. It should be left alone, unless you think it is not updated. If you do, please open an issue at https://github.com/JuliaSmoothOptimizers/CUTEst.jl

Core API

CUTEst.ccfg — Method.

ccfg

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

For more information, run the shell command

man cutest_ccfg

Usage:

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

ccfsg

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

For more information, run the shell command

man cutest_ccfsg

Usage:

ccfsg(io_err, n, m, x, c, nnzj, lj, j_val, j_var, j_fun, grad)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • m: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • c: [OUT] Array{Cdouble, 1}
  • nnzj: [OUT] Array{Cint, 1}
  • lj: [IN] Array{Cint, 1}
  • j_val: [OUT] Array{Cdouble, 1}
  • j_var: [OUT] Array{Cint, 1}
  • j_fun: [OUT] Array{Cint, 1}
  • grad: [IN] Array{Cint, 1}
CUTEst.cchprods — Method.

cchprods

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

For more information, run the shell command

man cutest_cchprods

Usage:

cchprods(io_err, n, m, goth, x, vector, lchp, chp_val, chp_ind, chp_ptr)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • m: [IN] Array{Cint, 1}
  • goth: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • vector: [IN] Array{Cdouble, 1}
  • lchp: [IN] Array{Cint, 1}
  • chp_val: [OUT] Array{Cdouble, 1}
  • chp_ind: [IN] Array{Cint, 1}
  • chp_ptr: [IN] Array{Cint, 1}
CUTEst.cchprodsp — Method.

cchprodsp

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

Usage:

cchprodsp(io_err, m, lchp, chp_ind, chp_ptr)
  • io_err: [OUT] Array{Cint, 1}
  • m: [IN] Array{Cint, 1}
  • lchp: [IN] Array{Cint, 1}
  • chp_ind: [IN] Array{Cint, 1}
  • chp_ptr: [IN] Array{Cint, 1}
CUTEst.ccifg — Method.

ccifg

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

For more information, run the shell command

man cutest_ccifg

Usage:

ccifg(io_err, n, icon, x, ci, gci, grad)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • icon: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • ci: [OUT] Array{Cdouble, 1}
  • gci: [OUT] Array{Cdouble, 1}
  • grad: [IN] Array{Cint, 1}
CUTEst.ccifsg — Method.

ccifsg

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

For more information, run the shell command

man cutest_ccifsg

Usage:

ccifsg(io_err, n, icon, x, ci, nnzgci, lgci, gci_val, gci_var, grad)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • icon: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • ci: [OUT] Array{Cdouble, 1}
  • nnzgci: [OUT] Array{Cint, 1}
  • lgci: [IN] Array{Cint, 1}
  • gci_val: [OUT] Array{Cdouble, 1}
  • gci_var: [OUT] Array{Cint, 1}
  • grad: [IN] Array{Cint, 1}
CUTEst.cdh — Method.

cdh

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

For more information, run the shell command

man cutest_cdh

Usage:

cdh(io_err, n, m, x, y, lh1, h_val)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • m: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • y: [IN] Array{Cdouble, 1}
  • lh1: [IN] Array{Cint, 1}
  • h_val: [OUT] Array{Cdouble, 2}
CUTEst.cdhc — Method.

cdhc

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

For more information, run the shell command

man cutest_cdhc

Usage:

cdhc(io_err, n, m, x, y, lh1, h_val)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • m: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • y: [IN] Array{Cdouble, 1}
  • lh1: [IN] Array{Cint, 1}
  • h_val: [OUT] Array{Cdouble, 2}
CUTEst.cdimchp — Method.

cdimchp

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

For more information, run the shell command

man cutest_cdimchp

Usage:

cdimchp(io_err, nnzchp)
  • io_err: [OUT] Array{Cint, 1}
  • nnzchp: [OUT] Array{Cint, 1}
CUTEst.cdimen — Method.

cdimen

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

For more information, run the shell command

man cutest_cdimen

Usage:

cdimen(io_err, input, n, m)
  • io_err: [OUT] Array{Cint, 1}
  • input: [IN] Array{Cint, 1}
  • n: [OUT] Array{Cint, 1}
  • m: [OUT] Array{Cint, 1}
CUTEst.cdimse — Method.

cdimse

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

For more information, run the shell command

man cutest_cdimse

Usage:

cdimse(io_err, ne, he_val_ne, he_row_ne)
  • io_err: [OUT] Array{Cint, 1}
  • ne: [OUT] Array{Cint, 1}
  • hevalne: [OUT] Array{Cint, 1}
  • herowne: [OUT] Array{Cint, 1}
CUTEst.cdimsh — Method.

cdimsh

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

For more information, run the shell command

man cutest_cdimsh

Usage:

cdimsh(io_err, nnzh)
  • io_err: [OUT] Array{Cint, 1}
  • nnzh: [OUT] Array{Cint, 1}
CUTEst.cdimsj — Method.

cdimsj

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

For more information, run the shell command

man cutest_cdimsj

Usage:

cdimsj(io_err, nnzj)
  • io_err: [OUT] Array{Cint, 1}
  • nnzj: [OUT] Array{Cint, 1}
CUTEst.ceh — Method.

ceh

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

For more information, run the shell command

man cutest_ceh

Usage:

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

herow, lheval, he_val, byrows)

  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • m: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • y: [IN] Array{Cdouble, 1}
  • ne: [OUT] Array{Cint, 1}
  • lhe_ptr: [IN] Array{Cint, 1}
  • herowptr: [OUT] Array{Cint, 1}
  • hevalptr: [OUT] Array{Cint, 1}
  • lhe_row: [IN] Array{Cint, 1}
  • he_row: [OUT] Array{Cint, 1}
  • lhe_val: [IN] Array{Cint, 1}
  • he_val: [OUT] Array{Cdouble, 1}
  • byrows: [IN] Array{Cint, 1}
CUTEst.cfn — Method.

cfn

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

For more information, run the shell command

man cutest_cfn

Usage:

cfn(io_err, n, m, x, f, c)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • m: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • f: [OUT] Array{Cdouble, 1}
  • c: [OUT] Array{Cdouble, 1}
CUTEst.cgr — Method.

cgr

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

For more information, run the shell command

man cutest_cgr

Usage:

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

cgrdh

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

For more information, run the shell command

man cutest_cgrdh

Usage:

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

chcprod

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

For more information, run the shell command

man cutest_chcprod

Usage:

chcprod(io_err, n, m, goth, x, y, vector, result)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • m: [IN] Array{Cint, 1}
  • goth: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • y: [IN] Array{Cdouble, 1}
  • vector: [IN] Array{Cdouble, 1}
  • result: [OUT] Array{Cdouble, 1}
CUTEst.chprod — Method.

chprod

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

For more information, run the shell command

man cutest_chprod

Usage:

chprod(io_err, n, m, goth, x, y, vector, result)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • m: [IN] Array{Cint, 1}
  • goth: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • y: [IN] Array{Cdouble, 1}
  • vector: [IN] Array{Cdouble, 1}
  • result: [OUT] Array{Cdouble, 1}
CUTEst.cidh — Method.

cidh

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

For more information, run the shell command

man cutest_cidh

Usage:

cidh(io_err, n, x, iprob, lh1, h)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • iprob: [IN] Array{Cint, 1}
  • lh1: [IN] Array{Cint, 1}
  • h: [OUT] Array{Cdouble, 2}
CUTEst.cifn — Method.

cifn

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

For more information, run the shell command

man cutest_cifn

Usage:

  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • iprob: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • f: [OUT] Array{Cdouble, 1}
CUTEst.cigr — Method.

cigr

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

For more information, run the shell command

man cutest_cigr
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • iprob: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • g_val: [OUT] Array{Cdouble, 1}
CUTEst.cisgr — Method.

cisgr

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

For more information, run the shell command

man cutest_cisgr

Usage:

  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • iprob: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • nnzg: [OUT] Array{Cint, 1}
  • lg: [IN] Array{Cint, 1}
  • g_val: [OUT] Array{Cdouble, 1}
  • g_var: [OUT] Array{Cint, 1}
CUTEst.cish — Method.

cish

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

For more information, run the shell command

man cutest_cish

Usage:

cish(io_err, n, x, iprob, nnzh, lh, h_val, h_row, h_col)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • iprob: [IN] Array{Cint, 1}
  • nnzh: [OUT] Array{Cint, 1}
  • lh: [IN] Array{Cint, 1}
  • h_val: [OUT] Array{Cdouble, 1}
  • h_row: [OUT] Array{Cint, 1}
  • h_col: [OUT] Array{Cint, 1}
CUTEst.cjprod — Method.

cjprod

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

For more information, run the shell command

man cutest_cjprod

Usage:

cjprod(io_err, n, m, gotj, jtrans, x, vector, lvector, result, lresult)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • m: [IN] Array{Cint, 1}
  • gotj: [IN] Array{Cint, 1}
  • jtrans: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • vector: [IN] Array{Cdouble, 1}
  • lvector: [IN] Array{Cint, 1}
  • result: [OUT] Array{Cdouble, 1}
  • lresult: [IN] Array{Cint, 1}
CUTEst.clfg — Method.

clfg

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

For more information, run the shell command

man cutest_clfg

Usage:

clfg(io_err, n, m, x, y, f, g, grad)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • m: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • y: [IN] Array{Cdouble, 1}
  • f: [OUT] Array{Cdouble, 1}
  • g: [OUT] Array{Cdouble, 1}
  • grad: [IN] Array{Cint, 1}
CUTEst.cnames — Method.

cnames

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

For more information, run the shell command

man cutest_cnames

Usage:

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

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

CUTEst.cofg — Method.

cofg

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

For more information, run the shell command

man cutest_cofg

Usage:

cofg(io_err, n, x, f, g, grad)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • f: [OUT] Array{Cdouble, 1}
  • g: [OUT] Array{Cdouble, 1}
  • grad: [IN] Array{Cint, 1}
CUTEst.cofsg — Method.

cofsg

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

For more information, run the shell command

man cutest_cofsg

Usage:

cofsg(io_err, n, x, f, nnzg, lg, g_val, g_var, grad)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • f: [OUT] Array{Cdouble, 1}
  • nnzg: [OUT] Array{Cint, 1}
  • lg: [IN] Array{Cint, 1}
  • g_val: [OUT] Array{Cdouble, 1}
  • g_var: [OUT] Array{Cint, 1}
  • grad: [IN] Array{Cint, 1}
CUTEst.connames — Method.

connames

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

For more information, run the shell command

man cutest_connames

Usage:

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

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

CUTEst.creport — Method.

creport

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

For more information, run the shell command

man cutest_creport

Usage:

creport(io_err, calls, time)
  • io_err: [OUT] Array{Cint, 1}
  • calls: [OUT] Array{Cdouble, 1}
  • time: [OUT] Array{Cdouble, 1}
CUTEst.csetup — Method.

csetup

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

For more information, run the shell command

man cutest_csetup

Usage:

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

linear, eorder, lorder, v_order)

  • io_err: [OUT] Array{Cint, 1}
  • input: [IN] Array{Cint, 1}
  • out: [IN] Array{Cint, 1}
  • io_buffer: [IN] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • m: [IN] Array{Cint, 1}
  • x: [OUT] Array{Cdouble, 1}
  • x_l: [OUT] Array{Cdouble, 1}
  • x_u: [OUT] Array{Cdouble, 1}
  • y: [OUT] Array{Cdouble, 1}
  • c_l: [OUT] Array{Cdouble, 1}
  • c_u: [OUT] Array{Cdouble, 1}
  • equatn: [OUT] Array{Cint, 1}
  • linear: [OUT] Array{Cint, 1}
  • e_order: [IN] Array{Cint, 1}
  • l_order: [IN] Array{Cint, 1}
  • v_order: [IN] Array{Cint, 1}
CUTEst.csgr — Method.

csgr

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

For more information, run the shell command

man cutest_csgr

Usage:

csgr(io_err, n, m, x, y, grlagf, nnzj, lj, j_val, j_var, j_fun)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • m: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • y: [IN] Array{Cdouble, 1}
  • grlagf: [IN] Array{Cint, 1}
  • nnzj: [OUT] Array{Cint, 1}
  • lj: [IN] Array{Cint, 1}
  • j_val: [OUT] Array{Cdouble, 1}
  • j_var: [OUT] Array{Cint, 1}
  • j_fun: [OUT] Array{Cint, 1}
CUTEst.csgreh — Method.

csgreh

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

For more information, run the shell command

man cutest_csgreh

Usage:

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

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

  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • m: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • y: [IN] Array{Cdouble, 1}
  • grlagf: [IN] Array{Cint, 1}
  • nnzj: [OUT] Array{Cint, 1}
  • lj: [IN] Array{Cint, 1}
  • j_val: [OUT] Array{Cdouble, 1}
  • j_var: [OUT] Array{Cint, 1}
  • j_fun: [OUT] Array{Cint, 1}
  • ne: [OUT] Array{Cint, 1}
  • lhe_ptr: [IN] Array{Cint, 1}
  • herowptr: [OUT] Array{Cint, 1}
  • hevalptr: [OUT] Array{Cint, 1}
  • lhe_row: [IN] Array{Cint, 1}
  • he_row: [OUT] Array{Cint, 1}
  • lhe_val: [IN] Array{Cint, 1}
  • he_val: [OUT] Array{Cdouble, 1}
  • byrows: [IN] Array{Cint, 1}
CUTEst.csgrp — Method.

csgrp

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

For more information, run the shell command

man cutest_csgrp

Usage:

csgrp(io_err, n, nnzj, lj, j_var, j_fun)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • nnzj: [OUT] Array{Cint, 1}
  • lj: [IN] Array{Cint, 1}
  • j_var: [OUT] Array{Cint, 1}
  • j_fun: [OUT] Array{Cint, 1}
CUTEst.csgrsh — Method.

csgrsh

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

For more information, run the shell command

man cutest_csgrsh

Usage:

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

hval, hrow, h_col)

  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • m: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • y: [IN] Array{Cdouble, 1}
  • grlagf: [IN] Array{Cint, 1}
  • nnzj: [OUT] Array{Cint, 1}
  • lj: [IN] Array{Cint, 1}
  • j_val: [OUT] Array{Cdouble, 1}
  • j_var: [OUT] Array{Cint, 1}
  • j_fun: [OUT] Array{Cint, 1}
  • nnzh: [OUT] Array{Cint, 1}
  • lh: [IN] Array{Cint, 1}
  • h_val: [OUT] Array{Cdouble, 1}
  • h_row: [OUT] Array{Cint, 1}
  • h_col: [OUT] Array{Cint, 1}
CUTEst.csgrshp — Method.

csgrshp

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

For more information, run the shell command

man cutest_csgrshp
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • nnzj: [OUT] Array{Cint, 1};
  • lj: [IN] Array{Cint, 1}
  • j_var: [OUT] Array{Cint, 1}
  • j_fun: [OUT] Array{Cint, 1}
  • nnzh: [OUT] Array{Cint, 1}
  • lh: [IN] Array{Cint, 1}
  • h_row: [OUT] Array{Cint, 1}
  • h_col: [OUT] Array{Cint, 1};
CUTEst.csh — Method.

csh

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

For more information, run the shell command

man cutest_csh

Usage:

csh(io_err, n, m, x, y, nnzh, lh, h_val, h_row, h_col)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • m: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • y: [IN] Array{Cdouble, 1}
  • nnzh: [OUT] Array{Cint, 1}
  • lh: [IN] Array{Cint, 1}
  • h_val: [OUT] Array{Cdouble, 1}
  • h_row: [OUT] Array{Cint, 1}
  • h_col: [OUT] Array{Cint, 1}
CUTEst.cshc — Method.

cshc

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

For more information, run the shell command

man cutest_cshc

Usage:

cshc(io_err, n, m, x, y, nnzh, lh, h_val, h_row, h_col)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • m: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • y: [IN] Array{Cdouble, 1}
  • nnzh: [OUT] Array{Cint, 1}
  • lh: [IN] Array{Cint, 1}
  • h_val: [OUT] Array{Cdouble, 1}
  • h_row: [OUT] Array{Cint, 1}
  • h_col: [OUT] Array{Cint, 1}
CUTEst.cshcprod — Method.

cshcprod

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

For more information, run the shell command

man cutest_cshcprod

Usage:

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

nnzresult, indexnz_result, result)

  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • m: [IN] Array{Cint, 1}
  • goth: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • y: [IN] Array{Cdouble, 1}
  • nnz_vector: [IN] Array{Cint, 1}
  • indexnzvector: [IN] Array{Cint, 1}
  • vector: [IN] Array{Cdouble, 1}
  • nnz_result: [OUT] Array{Cint, 1}
  • indexnzresult: [OUT] Array{Cint, 1}
  • result: [OUT] Array{Cdouble, 1}
CUTEst.cshp — Method.

cshp

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

For more information, run the shell command

man cutest_cshp

Usage:

cshp(io_err, n, nnzh, lh, h_row, h_col)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • nnzh: [OUT] Array{Cint, 1}
  • lh: [IN] Array{Cint, 1}
  • h_row: [OUT] Array{Cint, 1}
  • h_col: [OUT] Array{Cint, 1}
CUTEst.cshprod — Method.

cshprod

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

For more information, run the shell command

man cutest_cshprod

Usage:

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

nnzresult, indexnz_result, result)

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

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

CUTEst.csjprod — Method.

csjprod

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

For more information, run the shell command

man cutest_csjprod

Usage:

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

lvector, nnzresult, indexnz_result, result, lresult)

  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • m: [IN] Array{Cint, 1}
  • gotj: [IN] Array{Cint, 1}
  • jtrans: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • nnz_vector: [IN] Array{Cint, 1}
  • indexnzvector: [IN] Array{Cint, 1}
  • vector: [IN] Array{Cdouble, 1}
  • lvector: [IN] Array{Cint, 1}
  • nnz_result: [OUT] Array{Cint, 1}
  • indexnzresult: [OUT] Array{Cint, 1}
  • result: [OUT] Array{Cdouble, 1}
  • lresult: [IN] Array{Cint, 1}
CUTEst.cstats — Method.

cstats

cstats(io_err, nonlinear_variables_objective,

nonlinearvariablesconstraints, equalityconstraints, linearconstraints)

  • io_err: [OUT] Array{Cint, 1}
  • nonlinearvariablesobjective: [OUT] Array{Cint, 1}
  • nonlinearvariablesconstraints: [OUT] Array{Cint, 1}
  • equality_constraints: [OUT] Array{Cint, 1}
  • linear_constraints: [OUT] Array{Cint, 1}
CUTEst.cterminate — Method.

cterminate

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

For more information, run the shell command

man cutest_cterminate

Usage:

cterminate(io_err)
  • io_err: [OUT] Array{Cint, 1}
CUTEst.cvartype — Method.

cvartype

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

For more information, run the shell command

man cutest_cvartype

Usage:

cvartype(io_err, n, x_type)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • x_type: [OUT] Array{Cint, 1}
CUTEst.pname — Method.

pname

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

For more information, run the shell command

man cutest_pname

Usage:

pname(io_err, input, pname)
  • io_err: [OUT] Array{Cint, 1}
  • input: [IN] Array{Cint, 1}
  • pname: [OUT] Array{UInt8, 1}
CUTEst.probname — Method.

probname

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

For more information, run the shell command

man cutest_probname

Usage:

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

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

CUTEst.ubandh — Method.

ubandh

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

For more information, run the shell command

man cutest_ubandh

Usage:

ubandh(io_err, n, x, semibandwidth, h_band, lbandh, max_semibandwidth)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • semibandwidth: [IN] Array{Cint, 1}
  • h_band: [OUT] Array{Cdouble, 2}
  • lbandh: [IN] Array{Cint, 1}
  • max_semibandwidth: [OUT] Array{Cint, 1}
CUTEst.udh — Method.

udh

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

For more information, run the shell command

man cutest_udh

Usage:

udh(io_err, n, x, lh1, h)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • lh1: [IN] Array{Cint, 1}
  • h: [OUT] Array{Cdouble, 2}
CUTEst.udimen — Method.

udimen

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

For more information, run the shell command

man cutest_udimen

Usage:

udimen(io_err, input, n)
  • io_err: [OUT] Array{Cint, 1}
  • input: [IN] Array{Cint, 1}
  • n: [OUT] Array{Cint, 1}
CUTEst.udimse — Method.

udimse

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

For more information, run the shell command

man cutest_udimse

Usage:

udimse(io_err, ne, he_val_ne, he_row_ne)
  • io_err: [OUT] Array{Cint, 1}
  • ne: [OUT] Array{Cint, 1}
  • hevalne: [OUT] Array{Cint, 1}
  • herowne: [OUT] Array{Cint, 1}
CUTEst.udimsh — Method.

udimsh

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

For more information, run the shell command

man cutest_udimsh

Usage:

udimsh(io_err, nnzh)
  • io_err: [OUT] Array{Cint, 1}
  • nnzh: [OUT] Array{Cint, 1}
CUTEst.ueh — Method.

ueh

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

For more information, run the shell command

man cutest_ueh

Usage:

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

lheval, heval, byrows)

  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • ne: [OUT] Array{Cint, 1}
  • lhe_ptr: [IN] Array{Cint, 1}
  • herowptr: [OUT] Array{Cint, 1}
  • hevalptr: [OUT] Array{Cint, 1}
  • lhe_row: [IN] Array{Cint, 1}
  • he_row: [OUT] Array{Cint, 1}
  • lhe_val: [IN] Array{Cint, 1}
  • he_val: [OUT] Array{Cdouble, 1}
  • byrows: [IN] Array{Cint, 1}
CUTEst.ufn — Method.

ufn

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

For more information, run the shell command

man cutest_ufn

Usage:

ufn(io_err, n, x, f)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • f: [OUT] Array{Cdouble, 1}
CUTEst.ugr — Method.

ugr

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

For more information, run the shell command

man cutest_ugr

Usage:

ugr(io_err, n, x, g)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • g: [OUT] Array{Cdouble, 1}
CUTEst.ugrdh — Method.

ugrdh

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

For more information, run the shell command

man cutest_ugrdh

Usage:

ugrdh(io_err, n, x, g, lh1, h)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • g: [OUT] Array{Cdouble, 1}
  • lh1: [IN] Array{Cint, 1}
  • h: [OUT] Array{Cdouble, 2}
CUTEst.ugreh — Method.

ugreh

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

For more information, run the shell command

man cutest_ugreh

Usage:

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

lheval, heval, byrows)

  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • g: [OUT] Array{Cdouble, 1}
  • ne: [OUT] Array{Cint, 1}
  • lhe_ptr: [IN] Array{Cint, 1}
  • herowptr: [OUT] Array{Cint, 1}
  • hevalptr: [OUT] Array{Cint, 1}
  • lhe_row: [IN] Array{Cint, 1}
  • he_row: [OUT] Array{Cint, 1}
  • lhe_val: [IN] Array{Cint, 1}
  • he_val: [OUT] Array{Cdouble, 1}
  • byrows: [IN] Array{Cint, 1}
CUTEst.ugrsh — Method.

ugrsh

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

For more information, run the shell command

man cutest_ugrsh

Usage:

ugrsh(io_err, n, x, g, nnzh, lh, h_val, h_row, h_col)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • g: [OUT] Array{Cdouble, 1}
  • nnzh: [OUT] Array{Cint, 1}
  • lh: [IN] Array{Cint, 1}
  • h_val: [OUT] Array{Cdouble, 1}
  • h_row: [OUT] Array{Cint, 1}
  • h_col: [OUT] Array{Cint, 1}
CUTEst.uhprod — Method.

uhprod

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

For more information, run the shell command

man cutest_uhprod

Usage:

uhprod(io_err, n, goth, x, vector, result)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • goth: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • vector: [IN] Array{Cdouble, 1}
  • result: [OUT] Array{Cdouble, 1}
CUTEst.unames — Method.

unames

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

For more information, run the shell command

man cutest_unames

Usage:

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

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

CUTEst.uofg — Method.

uofg

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

For more information, run the shell command

man cutest_uofg

Usage:

uofg(io_err, n, x, f, g, grad)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • f: [OUT] Array{Cdouble, 1}
  • g: [OUT] Array{Cdouble, 1}
  • grad: [IN] Array{Cint, 1}
CUTEst.ureport — Method.

ureport

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

For more information, run the shell command

man cutest_ureport

Usage:

ureport(io_err, calls, time)
  • io_err: [OUT] Array{Cint, 1}
  • calls: [OUT] Array{Cdouble, 1}
  • time: [OUT] Array{Cdouble, 1}
CUTEst.usetup — Method.

usetup

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

For more information, run the shell command

man cutest_usetup

Usage:

usetup(io_err, input, out, io_buffer, n, x, x_l, x_u)
  • io_err: [OUT] Array{Cint, 1}
  • input: [IN] Array{Cint, 1}
  • out: [IN] Array{Cint, 1}
  • io_buffer: [IN] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • x: [OUT] Array{Cdouble, 1}
  • x_l: [OUT] Array{Cdouble, 1}
  • x_u: [OUT] Array{Cdouble, 1}
CUTEst.ush — Method.

ush

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

For more information, run the shell command

man cutest_ush

Usage:

ush(io_err, n, x, nnzh, lh, h_val, h_row, h_col)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • x: [IN] Array{Cdouble, 1}
  • nnzh: [OUT] Array{Cint, 1}
  • lh: [IN] Array{Cint, 1}
  • h_val: [OUT] Array{Cdouble, 1}
  • h_row: [OUT] Array{Cint, 1}
  • h_col: [OUT] Array{Cint, 1}
CUTEst.ushp — Method.

ushp

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

For more information, run the shell command

man cutest_ushp

Usage:

ushp(io_err, n, nnzh, lh, h_row, h_col)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • nnzh: [OUT] Array{Cint, 1}
  • lh: [IN] Array{Cint, 1}
  • h_row: [OUT] Array{Cint, 1}
  • h_col: [OUT] Array{Cint, 1}
CUTEst.ushprod — Method.

ushprod

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

For more information, run the shell command

man cutest_ushprod

Usage:

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

indexnzresult, result)

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

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

CUTEst.uterminate — Method.

uterminate

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

For more information, run the shell command

man cutest_uterminate

Usage:

uterminate(io_err)
  • io_err: [OUT] Array{Cint, 1}
CUTEst.uvartype — Method.

uvartype

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

For more information, run the shell command

man cutest_uvartype

Usage:

uvartype(io_err, n, x_type)
  • io_err: [OUT] Array{Cint, 1}
  • n: [IN] Array{Cint, 1}
  • x_type: [OUT] Array{Cint, 1}
CUTEst.varnames — Method.

varnames

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

For more information, run the shell command

man cutest_varnames

Usage:

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

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

Internal

CUTEst.sifdecoder — Method.

Decode problem and build shared library.

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