Solve a nonlinear program with Uno
uno_solve(
n,
lb,
ub,
sense,
obj,
grad,
m,
cl,
cu,
cons,
jac_rows,
jac_cols,
jac,
hess_rows,
hess_cols,
hess,
x0,
preset,
base_indexing,
verbose,
options = list(),
lagrangian_sign = c("negative", "positive"),
dual0 = NULL,
iter_callback = NULL,
log_callback = NULL
)a named list. The `optimization_status` and `solution_status` are **named integers** of the form `c(SUCCESS = 0L)`: the value is Uno's enum code and the name is its canonical label, so you can key a status map by `names(status)` and still read the code (e.g. `status[[1L]]`). The list also holds the objective, primal and dual solutions (`constraint_dual`, `lower_bound_dual`, `upper_bound_dual`), KKT residuals, and per-callback evaluation counters.
number of variables.
variable lower/upper bounds (length `n`; use `-Inf`/`Inf`).
`"minimize"` or `"maximize"`.
objective `function(x)` and its gradient `function(x)`.
number of constraints (0 for unconstrained).
constraint lower/upper bounds (length `m`).
constraint `function(x)` returning a length-`m` vector.
COO row/column indices of the Jacobian nonzeros.
Jacobian `function(x)` returning the nonzero values.
COO indices of the lower-triangular Hessian.
Lagrangian Hessian `function(x, sigma, lambda)` returning the lower-triangular nonzero values, or `NULL` (Uno then uses an L-BFGS approximation, which the HiGHS subproblem solver cannot use).
initial primal iterate (length `n`).
Uno preset, e.g. `"filtersqp"` (SQP) or `"ipopt"` (interior point, using MUMPS as the linear solver).
0 for C-style or 1 for Fortran-style COO indices.
if `FALSE`, suppress Uno's solution printout.
a named list of Uno solver options applied AFTER the preset (so they override it), e.g. `list(max_iterations = 200L, tolerance = 1e-8, linear_solver = "MUMPS")`. Each value is coerced to the option's declared Uno type; an unknown option name or an unacceptable value raises an error.
the Lagrangian multiplier sign convention the `hess` callback uses: `"positive"` for \(L = \sigma f + y^\top c\) (the standard convention used by IPOPT and the sparsediff oracle) or `"negative"` for \(L = \sigma f - y^\top c\). Defaults to `"negative"`, matching Uno's own C-API default. **Must match the convention your `hess` returns**, otherwise the Lagrangian Hessian's constraint terms get the wrong sign (invisible when all constraints are linear, since their Hessian is zero).
optional warm-start dual iterate, or `NULL` (Uno's default).
optional `function(info)` called at each acceptable iterate; return `TRUE` to terminate the solve early. `info` is a named list with `primals`, `lower_bound_dual`, `upper_bound_dual`, `constraint_dual`, `objective_multiplier`, and the `primal_feasibility`/`stationarity`/ `complementarity` residuals. Errors in the callback are caught and treated as "do not terminate". `NULL` disables it.
optional `function(text)` that receives Uno's output stream in chunks (a sink for the solver log); `NULL` leaves output on stdout. Independent of `verbose` (which controls how much Uno prints).