elastiqp 0.1.0__tar.gz → 0.2.0__tar.gz

{elastiqp-0.1.0 → elastiqp-0.2.0}/.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-14, 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.0}/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.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: elastiqp
-Version: 0.1.0
+Version: 0.2.0
 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.0}/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.0}/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;
 }
@@ -305,7 +299,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 +313,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 +366,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 +411,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 +423,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 +431,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 +479,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 +534,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 +542,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);

{elastiqp-0.1.0 → elastiqp-0.2.0}/bindings/jax_ffi.cc

@@ -4,14 +4,13 @@
 //   ElastiqpSolve:     (Q, q, A, b, G, h, penalty)
 //                        -> (x, t, y, z_t, z, xr, tr, yr, z_t_r, z_r, info)
 //   ElastiqpSolveWarm: (Q, q, A, b, G, h, penalty, x0, y0, z0)
-//                        -> (x, t, y, z_t, z, info)
+//                        -> (x, t, y, z_t, z, info)      (das and pdal only)
 //
 // method: 0 = das, 1 = pdal, 2 = ipm. max_iter is the backend's outer budget.
 // The *r block is the kappa-relaxed point the Python wrappers differentiate
-// at; it copies the tight solution when target_kappa <= 0, and das cannot
-// relax. info = [converged, iters, relax_converged], without the last entry
-// for the warm handler. A has 0 rows and b 0 entries when there are no
-// equalities.
+// at; it copies the tight solution when target_kappa <= 0. info = [converged,
+// iters, relax_converged], without the last entry for the warm handler. A has 0
+// rows and b 0 entries when there are no equalities.
 
 #include <algorithm>
 #include <cstdint>
@@ -46,7 +45,6 @@ template <>
 void apply_options(elastiqp::pdal::Solver& solver, double eps_abs,
                    int64_t max_iter, int64_t ruiz) {
   solver.settings.eps_abs = eps_abs;
-  solver.settings.eps_duality_gap_abs = eps_abs;
   solver.settings.max_outer_iter = static_cast<int>(max_iter);
   solver.settings.ruiz = ruiz != 0;
 }
@@ -54,22 +52,12 @@ template <>
 void apply_options(elastiqp::ipm::Solver& solver, double eps_abs,
                    int64_t max_iter, int64_t ruiz) {
   solver.settings.eps_abs = eps_abs;
-  solver.settings.eps_duality_gap_abs = eps_abs;
   solver.settings.max_iter = static_cast<int>(max_iter);
   solver.settings.ruiz = ruiz != 0;
 }
 
-template <typename SolverT>
-void apply_warm_start(SolverT& solver, const VectorXd& x0, const VectorXd& y0,
-                      const VectorXd& z0) {
-  if constexpr (std::is_same_v<SolverT, elastiqp::ipm::Solver>) {
-    solver.warm_start_from(x0, y0, z0);  // reconstructs + floors the slacks
-  } else {
-    solver.set_warm_start(x0, y0, z0);
-  }
-}
-
-// x0 != nullptr seeds the solve from (x0, y0, z0).
+// x0 != nullptr seeds the solve from (x0, y0, z0); the IPM has no warm
+// start (dispatch rejects it).
 template <typename SolverT>
 void run_solver(double eps_abs, int64_t max_iter, int64_t ruiz,
                 double target_kappa, int64_t n, int64_t m, int64_t p,
@@ -83,19 +71,18 @@ void run_solver(double eps_abs, int64_t max_iter, int64_t ruiz,
   solver.setup(MapMatrix(Q, n, n), MapVector(q, n), MapMatrix(A, m, n),
                MapVector(b, m), MapMatrix(G, p, n), MapVector(h, p),
                MapVector(penalty, p));
-  if (x0 != nullptr) {
-    apply_warm_start(solver, VectorXd(MapVector(x0, n)),
-                     VectorXd(MapVector(y0, m)), VectorXd(MapVector(z0, p)));
+  if constexpr (!std::is_same_v<SolverT, elastiqp::ipm::Solver>) {
+    if (x0 != nullptr) {
+      solver.set_warm_start(VectorXd(MapVector(x0, n)),
+                            VectorXd(MapVector(y0, m)),
+                            VectorXd(MapVector(z0, p)));
+    }
   }
   sol = solver.solve();
   // Gradient accuracy is set by the relax residual, so cap it at 1e-6.
-  if constexpr (std::is_same_v<SolverT, elastiqp::das::Solver>) {
-    rsol = sol;
-  } else {
-    rsol = (target_kappa > 0 && p > 0)
-               ? solver.relax(target_kappa, std::min(eps_abs, 1e-6), 50)
-               : sol;
-  }
+  rsol = (target_kappa > 0 && p > 0)
+             ? solver.relax(target_kappa, std::min(eps_abs, 1e-6), 50)
+             : sol;
 }
 
 ffi::Error dispatch(int64_t method, double eps_abs, int64_t max_iter,
@@ -107,11 +94,6 @@ ffi::Error dispatch(int64_t method, double eps_abs, int64_t max_iter,
                     elastiqp::Solution& rsol) {
   switch (method) {
     case 0:
-      if (target_kappa > 0 && p > 0) {
-        return ffi::Error(ffi::ErrorCode::kInvalidArgument,
-                          "method='das' has no kappa relaxation (not "
-                          "differentiable); use method='pdal' or 'ipm'");
-      }
       run_solver<elastiqp::das::Solver>(eps_abs, max_iter, ruiz, target_kappa,
                                         n, m, p, Q, q, A, b, G, h, penalty, x0,
                                         y0, z0, sol, rsol);
@@ -122,6 +104,11 @@ ffi::Error dispatch(int64_t method, double eps_abs, int64_t max_iter,
                                          y0, z0, sol, rsol);
       return ffi::Error::Success();
     case 2:
+      if (x0 != nullptr) {
+        return ffi::Error(ffi::ErrorCode::kInvalidArgument,
+                          "method='ipm' has no warm start; use method='das' "
+                          "or 'pdal'");
+      }
       run_solver<elastiqp::ipm::Solver>(eps_abs, max_iter, ruiz, target_kappa,
                                         n, m, p, Q, q, A, b, G, h, penalty, x0,
                                         y0, z0, sol, rsol);

elastiqp-0.2.0/cmake/elastiqpConfig.cmake.in

@@ -0,0 +1,18 @@
+@PACKAGE_INIT@
+
+include(CMakeFindDependencyMacro)
+find_dependency(Eigen3)
+
+include("${CMAKE_CURRENT_LIST_DIR}/elastiqpTargets.cmake")
+
+# The static C interface requires the C++ linker and runtime.
+if(TARGET elastiqp::elastiqp_c)
+  get_target_property(_elastiqp_c_type elastiqp::elastiqp_c TYPE)
+  get_property(_elastiqp_languages GLOBAL PROPERTY ENABLED_LANGUAGES)
+  if(_elastiqp_c_type STREQUAL "STATIC_LIBRARY"
+     AND NOT "CXX" IN_LIST _elastiqp_languages)
+    enable_language(CXX)
+  endif()
+endif()
+
+check_required_components(elastiqp)

{elastiqp-0.1.0 → elastiqp-0.2.0}/cmake/elastiqp_install.cmake

@@ -3,7 +3,14 @@ include(CMakePackageConfigHelpers)
 
 install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 
-install(TARGETS elastiqp EXPORT elastiqpTargets)
+set(_elastiqp_install_targets elastiqp)
+if(ELASTIQP_BUILD_C)
+  list(APPEND _elastiqp_install_targets elastiqp_c)
+endif()
+install(TARGETS ${_elastiqp_install_targets} EXPORT elastiqpTargets
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 install(EXPORT elastiqpTargets
   NAMESPACE elastiqp::
   DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/elastiqp)

{elastiqp-0.1.0 → elastiqp-0.2.0}/examples/basic_usage.py

@@ -121,8 +121,7 @@ def main():
     print("\nNote that this speedup can be significant on robot control problems!")
 
     print("\n--- Differentiability ---")
-    print("\nThe 'pdal' and 'ipm' backends can relax() a solution to the")
-    print("kappa-smoothed differentiation point; see the JAX and PyTorch examples")
+    print("For smooth derivative evaluation, see the JAX and PyTorch examples")
 
 
 if __name__ == "__main__":

{elastiqp-0.1.0 → elastiqp-0.2.0}/examples/jax_usage.py

@@ -68,9 +68,6 @@ def main():
     print("\nAs in solvers like qpax, we relax the solution to some kappa > 0")
     print("smoothed value for well-conditioned gradients")
 
-    print("\nNote: Currently, differentiation is only supported in the `ipm`")
-    print("and `pdal` backends")
-
     def loss(q_, kappa=1e-6):
         sol = elastiqp.jax.solve(
             Q,
@@ -80,7 +77,6 @@ def main():
             penalty,
             A=A,
             b=b,
-            method="pdal",
             target_kappa=kappa,
             eps_abs=1e-10,
         )
@@ -108,7 +104,7 @@ def main():
     def x0(h0, kappa):
         h_mod = h.at[0].set(h0)
         return elastiqp.jax.solve(
-            Q, q, G, h_mod, penalty, A=A, b=b, method="pdal", target_kappa=kappa
+            Q, q, G, h_mod, penalty, A=A, b=b, target_kappa=kappa
         ).x[0]
 
     print("\nTo see this, let's compare d(x0)/d(h0): the sensitivity of x0 to its")