elastiqp 0.1.0__tar.gz → 0.2.1__tar.gz

{elastiqp-0.1.0 → elastiqp-0.2.1}/.github/workflows/wheels.yml

@@ -1,6 +1,7 @@
-# Build manylinux + macOS wheels and an sdist, then publish to PyPI on a version tag.
+# Build manylinux, macOS, and Windows wheels and an sdist, then publish to PyPI on a version tag.
 #
-# Manual runs (workflow_dispatch) build everything and publish to TestPyPI.
+# Manual runs (workflow_dispatch) build everything, and publish to TestPyPI
+# only if the "publish" box is ticked.
 # Tag pushes matching v* publish to PyPI.
 #
 # Both publish jobs use PyPI trusted publishing (no API token): register this
@@ -17,6 +18,11 @@ on:
       - "pyproject.toml"
       - "CMakeLists.txt"
   workflow_dispatch:
+    inputs:
+      publish:
+        description: "Publish to TestPyPI"
+        type: boolean
+        default: false
 
 jobs:
   build_wheels:
@@ -25,7 +31,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, ubuntu-24.04-arm, macos-14]
+        os: [ubuntu-latest, ubuntu-24.04-arm, macos-15, windows-latest]
     steps:
       - uses: actions/checkout@v5
 
@@ -33,6 +39,7 @@ jobs:
         env:
           CIBW_BUILD: "cp39-* cp310-* cp311-* cp312-* cp313-*"
           CIBW_SKIP: "*-musllinux_* *_i686"
+          CIBW_ARCHS_WINDOWS: AMD64
           # AlmaLinux 8 based image: glibc 2.28, broad compatibility.
           CIBW_MANYLINUX_X86_64_IMAGE: manylinux_2_28
           CIBW_MANYLINUX_AARCH64_IMAGE: manylinux_2_28
@@ -40,6 +47,9 @@ jobs:
           CIBW_BEFORE_ALL_LINUX: dnf install -y epel-release && dnf install -y eigen3-devel
           CIBW_BEFORE_ALL_MACOS: brew install eigen
           CIBW_ENVIRONMENT_MACOS: MACOSX_DEPLOYMENT_TARGET=11.0
+          # vcpkg is preinstalled at C:\vcpkg on GitHub's Windows runners.
+          CIBW_BEFORE_ALL_WINDOWS: vcpkg install eigen3:x64-windows
+          CIBW_ENVIRONMENT_WINDOWS: CMAKE_PREFIX_PATH=C:/vcpkg/installed/x64-windows
           # Smoke-test each wheel from a clean venv (no ELASTIQP_BUILD_DIR set,
           # so the test imports the installed elastiqp._core).
           CIBW_TEST_COMMAND: python {project}/tests/test_bindings.py
@@ -67,7 +77,7 @@ jobs:
 
   publish_testpypi:
     name: publish to TestPyPI
-    if: github.event_name == 'workflow_dispatch'
+    if: github.event_name == 'workflow_dispatch' && inputs.publish
     needs: [build_wheels, build_sdist]
     runs-on: ubuntu-latest
     environment: testpypi

{elastiqp-0.1.0 → elastiqp-0.2.1}/CMakeLists.txt

@@ -18,8 +18,10 @@ else()
 endif()
 option(ELASTIQP_BUILD_TESTS "Build the elastiqp test suite" ${_elastiqp_top_level})
 option(ELASTIQP_BUILD_PYTHON "Build the Python bindings and JAX FFI" ${_elastiqp_top_level})
+option(ELASTIQP_BUILD_C "Build the C interface library (elastiqp_c)" ${_elastiqp_top_level})
 if(SKBUILD)  # pip wheel build: bindings only, no install/export
   set(ELASTIQP_BUILD_TESTS OFF)
+  set(ELASTIQP_BUILD_C OFF)
   set(ELASTIQP_BUILD_PYTHON ON)
 endif()
 
@@ -34,6 +36,27 @@ target_include_directories(elastiqp INTERFACE
 target_link_libraries(elastiqp INTERFACE Eigen3::Eigen)
 target_compile_features(elastiqp INTERFACE cxx_std_17)
 
+# C interface library
+if(ELASTIQP_BUILD_C)
+  enable_language(C)
+  add_library(elastiqp_c src/elastiqp_c.cc)
+  add_library(elastiqp::elastiqp_c ALIAS elastiqp_c)
+  target_link_libraries(elastiqp_c PRIVATE elastiqp::elastiqp)
+  target_include_directories(elastiqp_c PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>)
+  target_compile_definitions(elastiqp_c PRIVATE ELASTIQP_C_BUILDING)
+  if(BUILD_SHARED_LIBS)
+    target_compile_definitions(elastiqp_c PUBLIC ELASTIQP_C_SHARED)
+  endif()
+  set_target_properties(elastiqp_c PROPERTIES
+    CXX_VISIBILITY_PRESET hidden
+    VISIBILITY_INLINES_HIDDEN ON
+    POSITION_INDEPENDENT_CODE ON
+    VERSION ${PROJECT_VERSION}
+    SOVERSION ${PROJECT_VERSION_MAJOR})
+endif()
+
 # Headers for tests (never installed)
 add_library(elastiqp_testing INTERFACE)
 add_library(elastiqp::testing ALIAS elastiqp_testing)
@@ -55,6 +78,9 @@ if(ELASTIQP_BUILD_TESTS)
   elastiqp_test(test_das)
   add_test(NAME elastiqp.das COMMAND test_das)
 
+  elastiqp_test(test_das_alloc)
+  add_test(NAME elastiqp.das_alloc COMMAND test_das_alloc)
+
   elastiqp_test(test_pdal)
   add_test(NAME elastiqp.pdal COMMAND test_pdal)
 
@@ -72,16 +98,34 @@ if(ELASTIQP_BUILD_TESTS)
 
   elastiqp_test(test_lp)
   add_test(NAME elastiqp.lp COMMAND test_lp)
+
+  if(ELASTIQP_BUILD_C)
+    add_executable(test_c_api tests/test_c_api.c)
+    target_link_libraries(test_c_api PRIVATE elastiqp::elastiqp_c)
+    if(NOT MSVC)
+      target_link_libraries(test_c_api PRIVATE m)
+    endif()
+    add_test(NAME elastiqp.c_api COMMAND test_c_api)
+
+    elastiqp_test(test_c_parity)
+    target_link_libraries(test_c_parity PRIVATE elastiqp::elastiqp_c)
+    add_test(NAME elastiqp.c_parity COMMAND test_c_parity)
+  endif()
 endif()
 
 # Python bindings and JAX FFI
 if(ELASTIQP_BUILD_PYTHON)
   add_library(elastiqp_jax_ffi SHARED bindings/jax_ffi.cc)
-  target_include_directories(elastiqp_jax_ffi PRIVATE
+  target_include_directories(elastiqp_jax_ffi SYSTEM PRIVATE
     ${CMAKE_CURRENT_SOURCE_DIR}/third_party/xla_ffi)
   target_link_libraries(elastiqp_jax_ffi PRIVATE elastiqp::elastiqp)
+  # The XLA FFI handler symbols carry no dllexport; export them for ctypes.
+  set_target_properties(elastiqp_jax_ffi PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
   if(SKBUILD)
-    install(TARGETS elastiqp_jax_ffi LIBRARY DESTINATION elastiqp)
+    # A Windows DLL is a RUNTIME artifact, not a LIBRARY one.
+    install(TARGETS elastiqp_jax_ffi
+      LIBRARY DESTINATION elastiqp
+      RUNTIME DESTINATION elastiqp)
   endif()
 
   find_package(Python 3.8 COMPONENTS Interpreter Development.Module QUIET)

{elastiqp-0.1.0 → elastiqp-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: elastiqp
-Version: 0.1.0
+Version: 0.2.1
 Summary: An always-feasible QP solver for constrained robot control
 Author-Email: Daniel Morton <danielpmorton@gmail.com>
 License:    Copyright 2026 Daniel Morton
@@ -213,14 +213,14 @@ Provides-Extra: all
 Requires-Dist: elastiqp[dev,examples,jax,torch]; extra == "all"
 Description-Content-Type: text/markdown
 
+<div align="center">
+<img src="https://github.com/user-attachments/assets/12b43719-2b23-478d-9aaa-5481911741b4" alt="logo" width="400" height="73"></img>
+</div>
+
 # ElastiQP
 
 [![Paper](http://img.shields.io/badge/arXiv-2609.19080-B31B1B.svg)](https://arxiv.org/abs/2609.19080)
 
-> [!WARNING]  
-> Currently under construction, apologies for any rough edges
-
-
 An always-feasible QP solver for constrained robot control.
 
 ElastiQP solves the following problem:
@@ -281,9 +281,6 @@ If you've installed with CMake, you can also `find_package(elastiqp)`
 
 #### From PyPI
 
-> [!WARNING]  
-> The code is not yet available on PyPI but I will upload a copy shortly
-
 ```
 pip install elastiqp
 ```
@@ -312,7 +309,7 @@ Note: if using UV, you can directly replace the above `pip` commands with `uv pi
 elastiqp::Solution sol = elastiqp::Solve(Q, q, A, b, G, h, penalty);
 // or without equalities: elastiqp::Solve(Q, q, G, h, penalty)
 
-// If you are solving multiple times in a control loop:
+// Repeated solves
 elastiqp::Solver solver;
 solver.setup(Q, q, A, b, G, h, penalty);
 while (running) {
@@ -342,9 +339,6 @@ sol = solver.solve()
 
 ### JAX / PyTorch
 
-> [!WARNING]  
-> Differentiability support is still in beta, and is not implemented in the default (active set) backend
-
 ```python
 import jax
 jax.config.update("jax_enable_x64", True)
@@ -353,9 +347,9 @@ import elastiqp.jax
 # Same API as Python, just with elastiqp.jax
 sol = elastiqp.jax.solve(Q, q, G, h, penalty, A=A, b=b)
 
-# Compatible with jax.grad and vjp on the pdal / ipm backends
+# Compatible with jax.grad and vjp
 def loss(q_):
-    sol = elastiqp.jax.solve(Q, q_, G, h, penalty, A=A, b=b, method="ipm")
+    sol = elastiqp.jax.solve(Q, q_, G, h, penalty, A=A, b=b)
     return jnp.sum(sol.x**2)
 
 grad_q = jax.grad(loss)(q)
@@ -379,6 +373,29 @@ _, xs = jax.lax.scan(step, init, qs)
 
 For runnable Python/JAX/PyTorch examples, see the `examples` folder
 
+### C
+
+A new experimental C wrapper has recently been added for compatibility with libraries like [CasADi](https://github.com/casadi/casadi)
+
+```c
+#include "elastiqp/elastiqp_c.h"
+
+ElastiQPProblem qp = {.n = n, .m = m, .p = p, .Q = Q, .q = q, .A = A, .b = b,
+                      .G = G, .h = h, .penalty = penalty};
+ElastiQPSolution res = {.x = x, .z = z};
+elastiqp_solve_once(&res, &qp, NULL);  // NULL: default settings
+
+// Repeated solves
+ElastiQPWorkspace* work;
+elastiqp_setup(&work, &qp, NULL);
+while (running) {
+  elastiqp_set_q(work, q_k); elastiqp_set_h(work, h_k); elastiqp_set_b(work, b_k);
+  elastiqp_set_G(work, G_k);
+  if (elastiqp_solve(&res, work) != ELASTIQP_SOLVED) { /* ... */ }
+}
+elastiqp_free(work);
+```
+
 ## Benchmarks
 
 > [!WARNING]  

{elastiqp-0.1.0 → elastiqp-0.2.1}/README.md

@@ -1,11 +1,11 @@
+<div align="center">
+<img src="https://github.com/user-attachments/assets/12b43719-2b23-478d-9aaa-5481911741b4" alt="logo" width="400" height="73"></img>
+</div>
+
 # ElastiQP
 
 [![Paper](http://img.shields.io/badge/arXiv-2609.19080-B31B1B.svg)](https://arxiv.org/abs/2609.19080)
 
-> [!WARNING]  
-> Currently under construction, apologies for any rough edges
-
-
 An always-feasible QP solver for constrained robot control.
 
 ElastiQP solves the following problem:
@@ -66,9 +66,6 @@ If you've installed with CMake, you can also `find_package(elastiqp)`
 
 #### From PyPI
 
-> [!WARNING]  
-> The code is not yet available on PyPI but I will upload a copy shortly
-
 ```
 pip install elastiqp
 ```
@@ -97,7 +94,7 @@ Note: if using UV, you can directly replace the above `pip` commands with `uv pi
 elastiqp::Solution sol = elastiqp::Solve(Q, q, A, b, G, h, penalty);
 // or without equalities: elastiqp::Solve(Q, q, G, h, penalty)
 
-// If you are solving multiple times in a control loop:
+// Repeated solves
 elastiqp::Solver solver;
 solver.setup(Q, q, A, b, G, h, penalty);
 while (running) {
@@ -127,9 +124,6 @@ sol = solver.solve()
 
 ### JAX / PyTorch
 
-> [!WARNING]  
-> Differentiability support is still in beta, and is not implemented in the default (active set) backend
-
 ```python
 import jax
 jax.config.update("jax_enable_x64", True)
@@ -138,9 +132,9 @@ import elastiqp.jax
 # Same API as Python, just with elastiqp.jax
 sol = elastiqp.jax.solve(Q, q, G, h, penalty, A=A, b=b)
 
-# Compatible with jax.grad and vjp on the pdal / ipm backends
+# Compatible with jax.grad and vjp
 def loss(q_):
-    sol = elastiqp.jax.solve(Q, q_, G, h, penalty, A=A, b=b, method="ipm")
+    sol = elastiqp.jax.solve(Q, q_, G, h, penalty, A=A, b=b)
     return jnp.sum(sol.x**2)
 
 grad_q = jax.grad(loss)(q)
@@ -164,6 +158,29 @@ _, xs = jax.lax.scan(step, init, qs)
 
 For runnable Python/JAX/PyTorch examples, see the `examples` folder
 
+### C
+
+A new experimental C wrapper has recently been added for compatibility with libraries like [CasADi](https://github.com/casadi/casadi)
+
+```c
+#include "elastiqp/elastiqp_c.h"
+
+ElastiQPProblem qp = {.n = n, .m = m, .p = p, .Q = Q, .q = q, .A = A, .b = b,
+                      .G = G, .h = h, .penalty = penalty};
+ElastiQPSolution res = {.x = x, .z = z};
+elastiqp_solve_once(&res, &qp, NULL);  // NULL: default settings
+
+// Repeated solves
+ElastiQPWorkspace* work;
+elastiqp_setup(&work, &qp, NULL);
+while (running) {
+  elastiqp_set_q(work, q_k); elastiqp_set_h(work, h_k); elastiqp_set_b(work, b_k);
+  elastiqp_set_G(work, G_k);
+  if (elastiqp_solve(&res, work) != ELASTIQP_SOLVED) { /* ... */ }
+}
+elastiqp_free(work);
+```
+
 ## Benchmarks
 
 > [!WARNING]  

{elastiqp-0.1.0 → elastiqp-0.2.1}/bindings/bindings.cc

@@ -43,20 +43,14 @@ inline void apply_options(elastiqp::pdal::Settings& s,
                           std::optional<double> eps,
                           std::optional<int> max_iter,
                           std::optional<bool> ruiz) {
-  if (eps) {
-    s.eps_abs = *eps;
-    s.eps_duality_gap_abs = *eps;
-  }
+  if (eps) s.eps_abs = *eps;
   if (max_iter) s.max_outer_iter = *max_iter;
   if (ruiz) s.ruiz = *ruiz;
 }
 inline void apply_options(elastiqp::ipm::Settings& s, std::optional<double> eps,
                           std::optional<int> max_iter,
                           std::optional<bool> ruiz) {
-  if (eps) {
-    s.eps_abs = *eps;
-    s.eps_duality_gap_abs = *eps;
-  }
+  if (eps) s.eps_abs = *eps;
   if (max_iter) s.max_iter = *max_iter;
   if (ruiz) s.ruiz = *ruiz;
 }
@@ -291,6 +285,7 @@ NB_MODULE(_core, m) {
         .def_rw("eps_rel", &S::eps_rel)
         .def_rw("sing_tol", &S::sing_tol)
         .def_rw("zero_tol", &S::zero_tol)
+        .def_rw("cond_iters", &S::cond_iters)
         .def_rw("eps_prox", &S::eps_prox)
         .def_rw("eta_prox", &S::eta_prox)
         .def_rw("prox_relaxation", &S::prox_relaxation)
@@ -305,7 +300,9 @@ NB_MODULE(_core, m) {
         .def_rw("check_eq_consistency", &S::check_eq_consistency)
         .def_rw("progress_tol", &S::progress_tol)
         .def_rw("cycle_tol", &S::cycle_tol)
-        .def_rw("refactor_tol", &S::refactor_tol);
+        .def_rw("refactor_tol", &S::refactor_tol)
+        .def_rw("relax_reg", &S::relax_reg)
+        .def_rw("relax_factor_retries", &S::relax_factor_retries);
 
     using Sv = elastiqp::das::Solver;
     nb::enum_<Sv::RowState>(das, "RowState")
@@ -317,6 +314,7 @@ NB_MODULE(_core, m) {
     auto cls =
         nb::class_<Sv>(das, "Solver", "Dual active-set backend (default)");
     def_common(cls);
+    def_relax(cls, 50);
     cls.def("row_state", &Sv::row_state, nb::arg("i"),
             "RowState of inequality row i")
         .def("proximal", &Sv::proximal, "True if Q is proximally shifted")
@@ -369,45 +367,28 @@ NB_MODULE(_core, m) {
         .def_rw("bcl_release_jump", &S::bcl_release_jump)
         .def_rw("bcl_release_jump_horizon", &S::bcl_release_jump_horizon)
         .def_rw("bcl_warm_eta", &S::bcl_warm_eta)
-        .def_rw("cold_reset_mu", &S::cold_reset_mu)
-        .def_rw("cold_reset_threshold", &S::cold_reset_threshold)
-        .def_rw("cold_reset_residual", &S::cold_reset_residual)
-        .def_rw("cold_reset_limit", &S::cold_reset_limit)
         .def_rw("safe_guard", &S::safe_guard)
         .def_rw("ruiz", &S::ruiz)
         .def_rw("ruiz_max_iter", &S::ruiz_max_iter)
         .def_rw("ruiz_tol", &S::ruiz_tol)
         .def_rw("ruiz_refresh_ratio", &S::ruiz_refresh_ratio)
-        .def_rw("relax_reg", &S::relax_reg)
-        .def_rw("relax_warm_budget", &S::relax_warm_budget)
-        .def_rw("relax_warm_flip_tol", &S::relax_warm_flip_tol);
+        .def_rw("relax_reg", &S::relax_reg);
 
     using Sv = elastiqp::pdal::Solver;
     auto cls = nb::class_<Sv>(pdal, "Solver",
                               "Primal-dual augmented Lagrangian backend");
     def_common(cls);
+    def_relax(cls, 50);
     cls.def(
            "solution", [](const Sv& s) -> Solution { return s.solution(); },
            "Result of the last solve() or relax()")
         .def("factorizations", &Sv::factorizations,
              "KKT factorizations in the last solve()")
-        .def("cold_resets", &Sv::cold_resets,
-             "BCL cold resets in the last solve()")
         .def("reequilibrate", &Sv::reequilibrate,
              "Recompute the Ruiz scaling in place; solve() does this when "
              "drift exceeds settings.ruiz_refresh_ratio")
         .def("scaling_drift", &Sv::scaling_drift,
              "Largest factor a scaled row/column max-norm has drifted from 1")
-        .def(
-            "relax",
-            [](Sv& s, double kappa, double tol, int max_iter, bool warm)
-                -> Solution { return s.relax(kappa, tol, max_iter, warm); },
-            nb::arg("kappa"), nb::arg("tol") = 1e-6, nb::arg("max_iter") = 50,
-            nb::arg("warm") = true,
-            "Move the solve() result to the kappa-relaxed point (s.z = kappa) "
-            "for differentiation; the solver's own iterate stays tight. With "
-            "warm=True, repeated calls continue from the previous relaxed "
-            "point.")
         .def(
             "set_warm_start",
             [](Sv& s, const Eigen::VectorXd& x, const Eigen::VectorXd& y,
@@ -431,7 +412,6 @@ NB_MODULE(_core, m) {
         .def_rw("eps_duality_gap_abs", &S::eps_duality_gap_abs)
         .def_rw("eps_duality_gap_rel", &S::eps_duality_gap_rel)
         .def_rw("max_factor_retries", &S::max_factor_retries)
-        .def_rw("warm_start", &S::warm_start)
         .def_rw("check_eq_consistency", &S::check_eq_consistency)
         .def_rw("max_iter", &S::max_iter)
         .def_rw("rho_init", &S::rho_init)
@@ -444,9 +424,6 @@ NB_MODULE(_core, m) {
         .def_rw("reg_finetune_dual_update_threshold",
                 &S::reg_finetune_dual_update_threshold)
         .def_rw("tau", &S::tau)
-        .def_rw("warm_start_fraction", &S::warm_start_fraction)
-        .def_rw("warm_start_min_floor", &S::warm_start_min_floor)
-        .def_rw("warm_start_max_floor", &S::warm_start_max_floor)
         .def_rw("ruiz", &S::ruiz)
         .def_rw("ruiz_max_iter", &S::ruiz_max_iter)
         .def_rw("ruiz_tol", &S::ruiz_tol);
@@ -455,35 +432,8 @@ NB_MODULE(_core, m) {
     auto cls = nb::class_<Sv>(ipm, "Solver", "Proximal interior-point backend");
     def_common(cls);
     def_relax(cls, 30);
-    cls.def(
-           "solution", [](const Sv& s) -> Solution { return s.solution(); },
-           "Result of the last solve() or relax()")
-        .def(
-            "set_warm_start",
-            [](Sv& s, const Eigen::VectorXd& x, const Eigen::VectorXd& t,
-               const Eigen::VectorXd& y, const Eigen::VectorXd& s_t,
-               const Eigen::VectorXd& s_ineq, const Eigen::VectorXd& z_t,
-               const Eigen::VectorXd& z, double rho, double delta) {
-              s.set_warm_start(x, t, y, s_t, s_ineq, z_t, z, rho, delta);
-            },
-            nb::arg("x"), nb::arg("t"), nb::arg("y"), nb::arg("s_t"),
-            nb::arg("s_ineq"), nb::arg("z_t"), nb::arg("z"), nb::kw_only(),
-            nb::arg("rho") = 0.0, nb::arg("delta") = 0.0,
-            "Seed the next solve() with a strictly interior iterate, used as "
-            "given.")
-        .def(
-            "warm_start_from",
-            [](Sv& s, const Solution& sol) { s.warm_start_from(sol); },
-            nb::arg("solution"),
-            "Seed the next solve() from a Solution; slacks are rebuilt and "
-            "floored off the boundary.")
-        .def(
-            "warm_start_from",
-            [](Sv& s, const Eigen::VectorXd& x, const Eigen::VectorXd& y,
-               const Eigen::VectorXd& z) { s.warm_start_from(x, y, z); },
-            nb::arg("x"), nb::arg("y"), nb::arg("z"),
-            "Seed the next solve() from a user-frame (x, y, z); slacks are "
-            "rebuilt and floored off the boundary.");
+    cls.def("solution", [](const Sv& s) -> Solution { return s.solution(); },
+            "Result of the last solve() or relax()");
   }
 
   // --- one-shot solve ------------------------------------------------------
@@ -530,7 +480,7 @@ NB_MODULE(_core, m) {
       "method: 'das' (default), 'pdal' or 'ipm'. eps_abs, max_iter (outer "
       "budget) and ruiz override the backend defaults; settings= passes a "
       "full Settings object for that method.\n\n"
-      "For gradients use pdal.Solver or ipm.Solver with relax().";
+      "For gradients use a Solver object with relax().";
 
   m.def(
       "solve",
@@ -585,11 +535,6 @@ NB_MODULE(_core, m) {
          bool ruiz, double target_kappa, const std::string& method) {
         const Method mth = parse_method(method);
         const bool want_relax = target_kappa > 0 && h.size() > 0;
-        if (want_relax && mth == Method::kDAS) {
-          throw std::invalid_argument(
-              "method='das' has no kappa relaxation (not differentiable); "
-              "use method='pdal' or 'ipm' for gradients");
-        }
         Solution sol, rsol;
         // Gradient accuracy is set by the relax residual, so cap it at 1e-6.
         const double rtol = std::min(eps_abs, 1e-6);
@@ -598,7 +543,7 @@ NB_MODULE(_core, m) {
           apply_options(solver.settings, eps_abs, max_iter, ruiz);
           solver.setup(Q, q, A, b, G, h, penalty);
           sol = solver.solve();
-          rsol = sol;
+          rsol = want_relax ? solver.relax(target_kappa, rtol, 50) : sol;
         } else if (mth == Method::kPDAL) {
           elastiqp::pdal::Solver solver;
           apply_options(solver.settings, eps_abs, max_iter, ruiz);