`Clarabel.ConeDict`

— Constant`ConeDict`

A Dict that maps the user-facing SupportedCone types to the types used internally in the solver. See SupportedCone

`Clarabel.DefaultSolution`

— Type`DefaultSolution{T <: AbstractFloat}`

Object returned by the Clarabel solver after calling `optimize!(model)`

.

Fieldname | Description –- | :–- | :–- x | Vector{T}| Primal variable z | Vector{T}| Dual variable s | Vector{T}| (Primal) set variable status | Symbol | Solution status obj*val | T | Objective value (primal) obj*val*dual | T | Objective value (dual) solve*time | T | Solver run time iterations | Int | Number of solver iterations r*prim | primal residual at termination r*dual | dual residual at termination

If the status field indicates that the problem is solved then (x,z,s) are the calculated solution, or a best guess if the solver has terminated early due to time or iterations limits.

If the status indicates either primal or dual infeasibility, then (x,z,s) provide instead an infeasibility certificate.

`Clarabel.Settings`

— TypeArgument | Default Value | Description |
---|---|---|

Main Algorithm Settings | ||

max_iter | 200 | maximum number of iterations |

time_limit | Inf | maximum run time (seconds) |

verbose | true | verbose printing |

max_step_fraction | 0.99 | maximum interior point step length |

Full Accuracy Settings | ||

tol_gap_abs | 1e-8 | absolute duality gap tolerance |

tol_gap_rel | 1e-8 | relative duality gap tolerance |

tol_feas | 1e-8 | feasibility check tolerance (primal and dual) |

tol_infeas_abs | 1e-8 | absolute infeasibility tolerance (primal and dual) |

tol_infeas_rel | 1e-8 | relative infeasibility tolerance (primal and dual) |

tol_ktratio | 1e-6 | κ/τ tolerance |

Reduced Accuracy Settings | ||

reduced_tol_gap_abs | 5e-5 | reduced absolute duality gap tolerance |

reduced_tol_gap_rel | 5e-5 | reduced relative duality gap tolerance |

reduced_tol_feas | 1e-4 | reduced feasibility check tolerance (primal and dual) |

reduced_tol_infeas_abs | 5e-5 | reduced absolute infeasibility tolerance (primal and dual) |

reduced_tol_infeas_rel | 5e-5 | reduced relative infeasibility tolerance (primal and dual) |

reduced_tol_ktratio | 1e-4 | reduced κ/τ tolerance |

Data Equilibration Settings | ||

equilibrate_enable | true | enable data equilibration pre-scaling |

equilibrate_max_iter | 10 | maximum equilibration scaling iterations |

equilibrate_min_scaling | 1e-4 | minimum equilibration scaling allowed |

equilibrate_max_scaling | 1e+4 | maximum equilibration scaling allowed |

Step Size Settings | ||

linesearch_backtrack_step | 0.8 | linesearch backtracking |

min_switch_step_length | 1e-1 | minimum step size allowed for asymmetric cones with PrimalDual scaling |

min_terminate_step_length | 1e-4 | minimum step size allowed for symmetric cones & asymmetric cones with Dual scaling |

Linear Solver Settings | ||

direct_kkt_solver | true | use a direct linear solver method (required true) |

direct_solve_method | :qdldl | direct linear solver (e.g. :qdldl, :mkl, :panua, :ma57, :cholmod, :faer) |

static_regularization_enable | true | enable KKT static regularization |

static_regularization_eps | 1e-8 | KKT static regularization parameter |

static_regularization_proportional | eps(T)^2 | additional regularization parameter w.r.t. the maximum abs diagonal term |

dynamic_regularization_enable | true | enable KKT dynamic regularization |

dynamic_regularization_eps | 1e-13 | KKT dynamic regularization threshold |

dynamic_regularization_delta | 2e-7 | KKT dynamic regularization shift |

iterative_refinement_enable | true | KKT direct solve with iterative refinement |

iterative_refinement_reltol | 1e-12 | iterative refinement relative tolerance |

iterative_refinement_abstol | 1e-12 | iterative refinement absolute tolerance |

iterative_refinement_max_iter | 10 | iterative refinement maximum iterations |

iterative_refinement_stop_ratio | 5.0 | iterative refinement stalling tolerance |

Preprocessing Settings | ||

presolve_enable | true | enable presolve constraint reduction |

Chordal Decomposition Settings | ||

chordal_decomposition_enable | true | enable chordal decomposition |

chordal_decomposition_merge_method | :clique_graph | chordal decomposition merge method (:clique_graph, :parent_child or :none) |

chordal_decomposition_compact | true | assemble decomposed system in "compact" form |

chordal_decomposition_complete_dual | false | complete PSD dual variables after decomposition |

`Clarabel.Solver`

— Type`Solver{T <: AbstractFloat}()`

Initializes an empty Clarabel solver that can be filled with problem data using:

`setup!(solver, P, q, A, b, cones, [settings]).`

`Clarabel.SolverStatus`

— Type`SolverStatus`

An Enum of of possible conditions set by `solve!`

.

If no call has been made to `solve!`

, then the `SolverStatus`

is:

`UNSOLVED`

: The algorithm has not started.

Otherwise:

`SOLVED`

: Solver terminated with a solution.`PRIMAL_INFEASIBLE`

: Problem is primal infeasible. Solution returned is a certificate of primal infeasibility.`DUAL_INFEASIBLE`

: Problem is dual infeasible. Solution returned is a certificate of dual infeasibility.`ALMOST_SOLVED`

: Solver terminated with a solution (reduced accuracy).`ALMOST_PRIMAL_INFEASIBLE`

: Problem is primal infeasible. Solution returned is a certificate of primal infeasibility (reduced accuracy).`ALMOST_DUAL_INFEASIBLE`

: Problem is dual infeasible. Solution returned is a certificate of dual infeasibility (reduced accuracy).`MAX_ITERATIONS`

: Iteration limit reached before solution or infeasibility certificate found.`MAX_TIME`

: Time limit reached before solution or infeasibility certificate found.`NUMERICAL_ERROR`

: Solver terminated with a numerical error.`INSUFFICIENT_PROGRESS`

: Solver terminated due to lack of progress.

`Clarabel.SupportedCone`

— Type`SupportedCone`

An abstract type use by the Clarabel API used when passing cone specifications to the solver `setup!`

. The currently supported concrete types are:

`ZeroConeT`

: The zero cone. Used to define equalities.`NonnegativeConeT`

: The nonnegative orthant.`SecondOrderConeT`

: The second order / Lorentz / ice-cream cone.`ExponentialConeT`

: The exponential cone (in R^3)`PowerConeT`

: The power cone with power α (in R^3)`GenPowerConeT`

: The generalized power cone`PSDTriangleConeT`

: The positive semidefinite cone (triangular format).

`Clarabel.read_from_file`

— Method`read_from_file(filename)`

Creat a `Clarabel.Solver`

object from data in `filename`

previously written by `write_to_file`

.

`Clarabel.setup!`

— Method`setup!(solver, P, q, A, b, cones, [settings])`

Populates a `Solver`

with a cost function defined by `P`

and `q`

, and one or more conic constraints defined by `A`

, `b`

and a description of a conic constraint composed of cones whose types and dimensions are specified by `cones.`

The solver will be configured to solve the following optimization problem:

```
min 1/2 x'Px + q'x
s.t. Ax + s = b, s ∈ K
```

All data matrices must be sparse. The matrix `P`

is assumed to be symmetric and positive semidefinite, and only the upper triangular part is used.

The cone `K`

is a composite cone. To define the cone the user should provide a vector of cone specifications along with the appropriate dimensional information. For example, to generate a cone in the nonnegative orthant followed by a second order cone, use:

```
cones = [Clarabel.NonnegativeConeT(dim_1),
Clarabel.SecondOrderConeT(dim_2)]
```

If the argument 'cones' is constructed incrementally, the should should initialize it as an empty array of the supertype for all allowable cones, e.g.

```
cones = Clarabel.SupportedCone[]
push!(cones,Clarabel.NonnegativeConeT(dim_1))
...
```

The optional argument `settings`

can be used to pass custom solver settings:

```
settings = Clarabel.Settings(verbose = true)
setup!(model, P, q, A, b, cones, settings)
```

To solve the problem, you must make a subsequent call to `solve!`

`Clarabel.solve!`

— Method`solve!(solver)`

Computes the solution to the problem in a `Clarabel.Solver`

previously defined in `setup!`

.

`Clarabel.write_to_file`

— Method`write_to_file(solver, filename)`

Write the problem data in a `Clarabel.Solver`

to `filename`

in JSON format. The data is written in a format that can be read back into a `Clarabel.Solver`

using `read_from_file`

. The problem data will be written in unscaled form, but in the internal format used by the solver after applying chordal decomposition and presolve. It is not necessary to solve the problem before writing it to a file.