Clarabel.rs

Clarabel.rs is a Rust implementation of an interior point numerical solver for convex optimization problems. It uses a novel homogeneous embedding that allows it to handle quadratic objectives directly without requiring epigraphical reformulation, making it potentially faster than standard HSDE-based solvers for quadratic problems.

It solves problems of the form:

Minimize: $\frac{1}{2}x^T P x + q^T x$ Subject to: $Ax + s = b$ and $s \in \mathcal{K}$

Where $\mathcal{K}$ is a composition of convex cones.

Supported Problem Types:

• Linear Programs (LPs)
• Quadratic Programs (QPs)
• Second-Order Cone Programs (SOCPs)
• Semidefinite Programs (SDPs)
• Problems with exponential, power cone, and generalized power cone constraints.

The ClarabelRs package is a Julia wrapper for the Rust implementation of Clarabel.

Warning: This package is intended only for development and benchmarking purposes by the Clarabel developers. It is unstable and may be modified, withdrawn, or broken without warning.

For standard users, the native Julia implementation (Clarabel.jl) is the preferred choice. Because the main Clarabel.jl package provides a shared Modeling Interface (MOI) wrapper, tools like JuMP are compatible with both the native Julia version and this Rust-based wrapper.

If you want to use the Clarabel solver in Julia for production or general use, it is recommended to use the native Julia implementation (Clarabel.jl) rather than this Rust wrapper. You can install it directly via the Julia package manager:

using Pkg
Pkg.add("Clarabel")

Or using the REPL package mode:

# In the Julia REPL, press "]" to enter package mode
add Clarabel

To use Clarabel.rs in a Rust project, add it to your Cargo.toml dependencies.

For installation from source, refer to the Rust Installation Documentation.

[dependencies]
clarabel = "0"

To use the Python interface, install the package via pip.

For installation from source, refer to the Python Installation Documentation.

pip install clarabel

To implement a new solver for a specific problem format in Clarabel, you must implement a collection of mutually associated traits. These traits define how problem data, variables, residuals, KKT systems, and settings interact.

Note: In nearly all cases, users do not need to implement these traits manually. Instead, you should use the types provided in the Default solver implementation, which are already configured for the standard problem formats supported by Clarabel.

The FloatT trait is the primary abstraction for floating-point types used throughout the Clarabel solver. All internal calculations are performed using types that implement this trait.

By default, FloatT requires a type to satisfy CoreFloatT (which includes standard num_traits like Float, FloatConst, and FromPrimitive). Depending on the enabled features, additional constraints are applied:

• sdp feature: If enabled, FloatT is restricted to types that implement BlasFloatT (typically f32 and f64) to ensure compatibility with BLAS/LAPACK libraries.
• faer-sparse feature: If enabled, FloatT is restricted to types implementing faer_traits::RealField.

If SDP support is disabled, Clarabel can theoretically support any floating-point type that satisfies the CoreFloatT bounds.

Use the QDLDLSettings builder to customize the factorization process. Key configuration options include:

• amd_dense_scale: "dense scale" parameter for AMD ordering (default 1.0).
• perm: An optional user-supplied custom permutation vector.
• logical: If true, performs a symbolic-only factorization (no numerical values computed).
• Dsigns: Optional user-supplied signs for the diagonal elements of $D$ in $LDL^T$.
• regularize_enable: Enables regularization during factorization (default true).
• regularize_eps: Regularization epsilon parameter.
• regularize_delta: Regularization delta parameter.

let settings = QDLDLSettingsBuilder::<f64>::default()
    .logical(false)
    .regularize_enable(true)
    .amd_dense_scale(1.5)
    .build();

let factorization = QDLDLFactorisation::new(&Ain, Some(settings))?;

You can easily construct a CscMatrix from a slice of arrays (representing rows) using the From trait. This is convenient for small matrices where manual CSC construction is cumbersome.

use clarabel::algebra::CscMatrix;

let A = CscMatrix::from(&[
     [1.0, 2.0],
     [3.0, 0.0],
     [0.0, 4.0],
]);

If your data is in triplet format (row indices, column indices, and values), use new_from_triplets. This method handles unsorted data and consolidates repeated entries by adding them together.

Note: This method panics if the input vectors I, J, and V have mismatched lengths.

use clarabel::algebra::CscMatrix;

// m: rows, n: cols, I: row indices, J: col indices, V: values
let B = CscMatrix::new_from_triplets(3, 4, rows, cols, vals);