elastiqp 0.2.0__tar.gz → 0.2.1__tar.gz

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

@@ -31,7 +31,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, ubuntu-24.04-arm, macos-14, windows-latest]
+        os: [ubuntu-latest, ubuntu-24.04-arm, macos-15, windows-latest]
     steps:
       - uses: actions/checkout@v5
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: elastiqp
-Version: 0.2.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

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

@@ -285,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)

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

@@ -1,16 +1,16 @@
 // XLA FFI handlers for ElastiQP. Every call builds a fresh solver (XLA
 // assumes purity), so warm starting is an explicit argument.
 //
-//   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)      (das and pdal only)
+//   ElastiqpSolve: (Q, q, A, b, G, h, penalty, x0, y0, z0)
+//                    -> (x, t, y, z_t, z, xr, tr, yr, z_t_r, z_r, info)
 //
 // method: 0 = das, 1 = pdal, 2 = ipm. max_iter is the backend's outer budget.
+// warm != 0 seeds the solve from (x0, y0, z0) (das and pdal only); otherwise
+// they are ignored.
 // The *r block is the kappa-relaxed point the Python wrappers differentiate
 // 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.
+// iters, relax_converged]. A has 0 rows and b 0 entries when there are no
+// equalities.
 
 #include <algorithm>
 #include <cstdint>
@@ -134,9 +134,11 @@ void write_solution(const elastiqp::Solution& sol, int64_t n, int64_t m,
 
 ffi::Error ElastiqpSolveImpl(
     double eps_abs, int64_t max_iter, int64_t ruiz, double target_kappa,
-    int64_t method, ffi::Buffer<ffi::F64> Q, ffi::Buffer<ffi::F64> q,
-    ffi::Buffer<ffi::F64> A, ffi::Buffer<ffi::F64> b, ffi::Buffer<ffi::F64> G,
-    ffi::Buffer<ffi::F64> h, ffi::Buffer<ffi::F64> penalty,
+    int64_t warm, int64_t method, ffi::Buffer<ffi::F64> Q,
+    ffi::Buffer<ffi::F64> q, ffi::Buffer<ffi::F64> A, ffi::Buffer<ffi::F64> b,
+    ffi::Buffer<ffi::F64> G, ffi::Buffer<ffi::F64> h,
+    ffi::Buffer<ffi::F64> penalty, ffi::Buffer<ffi::F64> x0,
+    ffi::Buffer<ffi::F64> y0, ffi::Buffer<ffi::F64> z0,
     ffi::ResultBuffer<ffi::F64> x, ffi::ResultBuffer<ffi::F64> t,
     ffi::ResultBuffer<ffi::F64> y, ffi::ResultBuffer<ffi::F64> z_t,
     ffi::ResultBuffer<ffi::F64> z, ffi::ResultBuffer<ffi::F64> xr,
@@ -146,37 +148,9 @@ ffi::Error ElastiqpSolveImpl(
   const int64_t n = q.dimensions()[0];
   const int64_t m = b.dimensions()[0];
   const int64_t p = h.dimensions()[0];
-
-  elastiqp::Solution sol, rsol;
-  ffi::Error err =
-      dispatch(method, eps_abs, max_iter, ruiz, target_kappa, n, m, p,
-               Q.typed_data(), q.typed_data(), A.typed_data(), b.typed_data(),
-               G.typed_data(), h.typed_data(), penalty.typed_data(), nullptr,
-               nullptr, nullptr, sol, rsol);
-  if (err.failure()) return err;
-
-  write_solution(sol, n, m, p, x, t, y, z_t, z);
-  write_solution(rsol, n, m, p, xr, tr, yr, z_t_r, z_r);
-  info->typed_data()[0] = static_cast<double>(sol.converged);
-  info->typed_data()[1] = static_cast<double>(sol.iters);
-  info->typed_data()[2] = static_cast<double>(rsol.converged);
-  return ffi::Error::Success();
-}
-
-ffi::Error ElastiqpSolveWarmImpl(
-    double eps_abs, int64_t max_iter, int64_t ruiz, int64_t method,
-    ffi::Buffer<ffi::F64> Q, ffi::Buffer<ffi::F64> q, ffi::Buffer<ffi::F64> A,
-    ffi::Buffer<ffi::F64> b, ffi::Buffer<ffi::F64> G, ffi::Buffer<ffi::F64> h,
-    ffi::Buffer<ffi::F64> penalty, ffi::Buffer<ffi::F64> x0,
-    ffi::Buffer<ffi::F64> y0, ffi::Buffer<ffi::F64> z0,
-    ffi::ResultBuffer<ffi::F64> x, ffi::ResultBuffer<ffi::F64> t,
-    ffi::ResultBuffer<ffi::F64> y, ffi::ResultBuffer<ffi::F64> z_t,
-    ffi::ResultBuffer<ffi::F64> z, ffi::ResultBuffer<ffi::F64> info) {
-  const int64_t n = q.dimensions()[0];
-  const int64_t m = b.dimensions()[0];
-  const int64_t p = h.dimensions()[0];
-  if (x0.dimensions()[0] != n || y0.dimensions()[0] != m ||
-      z0.dimensions()[0] != p) {
+  const bool w = warm != 0;
+  if (w && (x0.dimensions()[0] != n || y0.dimensions()[0] != m ||
+            z0.dimensions()[0] != p)) {
     return ffi::Error(ffi::ErrorCode::kInvalidArgument,
                       "warm start (x0, y0, z0) must have shapes (n,), (m,), "
                       "(p,) matching (q, b, h)");
@@ -184,15 +158,18 @@ ffi::Error ElastiqpSolveWarmImpl(
 
   elastiqp::Solution sol, rsol;
   ffi::Error err =
-      dispatch(method, eps_abs, max_iter, ruiz, 0.0, n, m, p, Q.typed_data(),
-               q.typed_data(), A.typed_data(), b.typed_data(), G.typed_data(),
-               h.typed_data(), penalty.typed_data(), x0.typed_data(),
-               y0.typed_data(), z0.typed_data(), sol, rsol);
+      dispatch(method, eps_abs, max_iter, ruiz, target_kappa, n, m, p,
+               Q.typed_data(), q.typed_data(), A.typed_data(), b.typed_data(),
+               G.typed_data(), h.typed_data(), penalty.typed_data(),
+               w ? x0.typed_data() : nullptr, w ? y0.typed_data() : nullptr,
+               w ? z0.typed_data() : nullptr, sol, rsol);
   if (err.failure()) return err;
 
   write_solution(sol, n, m, p, x, t, y, z_t, z);
+  write_solution(rsol, n, m, p, xr, tr, yr, z_t_r, z_r);
   info->typed_data()[0] = static_cast<double>(sol.converged);
   info->typed_data()[1] = static_cast<double>(sol.iters);
+  info->typed_data()[2] = static_cast<double>(rsol.converged);
   return ffi::Error::Success();
 }
 
@@ -204,6 +181,7 @@ XLA_FFI_DEFINE_HANDLER_SYMBOL(ElastiqpSolve, ElastiqpSolveImpl,
                                   .Attr<int64_t>("max_iter")
                                   .Attr<int64_t>("ruiz")
                                   .Attr<double>("target_kappa")
+                                  .Attr<int64_t>("warm")
                                   .Attr<int64_t>("method")
                                   .Arg<ffi::Buffer<ffi::F64>>()  // Q
                                   .Arg<ffi::Buffer<ffi::F64>>()  // q
@@ -212,6 +190,9 @@ XLA_FFI_DEFINE_HANDLER_SYMBOL(ElastiqpSolve, ElastiqpSolveImpl,
                                   .Arg<ffi::Buffer<ffi::F64>>()  // G
                                   .Arg<ffi::Buffer<ffi::F64>>()  // h
                                   .Arg<ffi::Buffer<ffi::F64>>()  // penalty
+                                  .Arg<ffi::Buffer<ffi::F64>>()  // x0
+                                  .Arg<ffi::Buffer<ffi::F64>>()  // y0
+                                  .Arg<ffi::Buffer<ffi::F64>>()  // z0
                                   .Ret<ffi::Buffer<ffi::F64>>()  // x
                                   .Ret<ffi::Buffer<ffi::F64>>()  // t
                                   .Ret<ffi::Buffer<ffi::F64>>()  // y
@@ -224,27 +205,3 @@ XLA_FFI_DEFINE_HANDLER_SYMBOL(ElastiqpSolve, ElastiqpSolveImpl,
                                   .Ret<ffi::Buffer<ffi::F64>>()  // z_r
                                   .Ret<ffi::Buffer<ffi::F64>>()  // info
 );
-
-XLA_FFI_DEFINE_HANDLER_SYMBOL(ElastiqpSolveWarm, ElastiqpSolveWarmImpl,
-                              ffi::Ffi::Bind()
-                                  .Attr<double>("eps_abs")
-                                  .Attr<int64_t>("max_iter")
-                                  .Attr<int64_t>("ruiz")
-                                  .Attr<int64_t>("method")
-                                  .Arg<ffi::Buffer<ffi::F64>>()  // Q
-                                  .Arg<ffi::Buffer<ffi::F64>>()  // q
-                                  .Arg<ffi::Buffer<ffi::F64>>()  // A
-                                  .Arg<ffi::Buffer<ffi::F64>>()  // b
-                                  .Arg<ffi::Buffer<ffi::F64>>()  // G
-                                  .Arg<ffi::Buffer<ffi::F64>>()  // h
-                                  .Arg<ffi::Buffer<ffi::F64>>()  // penalty
-                                  .Arg<ffi::Buffer<ffi::F64>>()  // x0
-                                  .Arg<ffi::Buffer<ffi::F64>>()  // y0
-                                  .Arg<ffi::Buffer<ffi::F64>>()  // z0
-                                  .Ret<ffi::Buffer<ffi::F64>>()  // x
-                                  .Ret<ffi::Buffer<ffi::F64>>()  // t
-                                  .Ret<ffi::Buffer<ffi::F64>>()  // y
-                                  .Ret<ffi::Buffer<ffi::F64>>()  // z_t
-                                  .Ret<ffi::Buffer<ffi::F64>>()  // z
-                                  .Ret<ffi::Buffer<ffi::F64>>()  // info
-);

{elastiqp-0.2.0 → elastiqp-0.2.1}/include/elastiqp/das.hpp

@@ -21,8 +21,12 @@ struct Settings {
   double eps_rel = 0.0;
   // Working-set LDL^T pivot below this = dependent row.
   double sing_tol = 3.7e-11;
-  // Min/max Cholesky pivot ratio accepted for Q_s before adding a prox shift.
+  // Min/max eigenvalue ratio accepted for Q_s before adding a prox shift,
+  // judged from the Cholesky pivots (see cond_iters).
   double zero_tol = 1e-11;
+  // Inverse-iteration steps confirming the smallest eigenvalue of Q_s against
+  // zero_tol when the pivot ratio is below sqrt(zero_tol); 0 = pivots only.
+  int cond_iters = 3;
   // Initial prox shift (x max|diag Q_s|) when Q_s is not PD; 0 disables.
   double eps_prox = 1e-6;
   // Outer-loop tolerance on eps*|x - xc|_inf; 0 -> eps_abs.
@@ -109,6 +113,7 @@ class Solver {
     fx_.resize(n_);
     fr_.resize(mp_);
     xu_.resize(n_);
+    eig_work_.resize(n_);
     changed_.reserve(static_cast<size_t>(mp_));
     changed_cols_.resize(n_, mp_);
     warm_x_.setZero(n_);
@@ -305,16 +310,23 @@ class Solver {
       int inner = 0;
       st = ldp(inner);
       sol_.iters += inner;
-      if (st == Status::kNumerics && eps_ > 0 &&
+      if (st == Status::kNumerics && settings.eps_prox > 0 &&
           escalations < settings.prox_escalations) {
         // Inner loop broke down: recenter at the current x, grow the prox shift
-        // 100x, restart.
+        // 100x (or turn it on), restart.
         escalations++;
         prox_escalated_ = true;
         for (int i = 0; i < static_cast<int>(W_.size()); ++i)
           lam_full_[W_[static_cast<size_t>(i)]] = lam_[i];
-        xc_ = llt_.matrixU().solve(u_ - v_);
-        if (!factor(100.0 * eps_)) return finish(Status::kNumerics);
+        double eps_next = 100.0 * eps_;
+        if (eps_ > 0) {
+          xc_ = llt_.matrixU().solve(u_ - v_);
+        } else {
+          xc_ = x_;
+          eps_next = settings.eps_prox *
+                     std::max(1.0, Qs_.diagonal().cwiseAbs().maxCoeff());
+        }
+        if (!factor(eps_next)) return finish(Status::kNumerics);
         for (int i = 0; i < mp_; ++i)
           tol_[i] = (settings.eps_abs + settings.eps_rel * std::abs(rhs_[i])) *
                     scale_[i] * dr_[i];
@@ -653,6 +665,9 @@ class Solver {
           pmax = std::max(pmax, piv * piv);
         }
         ok = pmin > settings.zero_tol * pmax && pmin > 0;
+        if (ok && settings.cond_iters > 0 &&
+            pmin < std::sqrt(settings.zero_tol) * pmax)
+          ok = min_eig_estimate() > settings.zero_tol * (scale + eps_);
       }
       if (ok) break;
       if (settings.eps_prox <= 0) return false;
@@ -667,6 +682,18 @@ class Solver {
     rhs_dirty_ = true;
     return true;
   }
+  // Upper estimate of the smallest eigenvalue of the factored matrix
+  double min_eig_estimate() {
+    for (int i = 0; i < n_; ++i)
+      eig_work_[i] = 1.0 + static_cast<double>(i) / n_;
+    double est = std::numeric_limits<double>::infinity();
+    for (int it = 0; it < settings.cond_iters; ++it) {
+      eig_work_ /= eig_work_.norm();
+      llt_.solveInPlace(eig_work_);
+      est = 1.0 / eig_work_.norm();
+    }
+    return est;
+  }
   void normalize_row(int i) {
     const double nrm = Mt_.col(i).norm();
     scale_[i] = nrm > 1e-300 ? 1.0 / nrm : 1.0;
@@ -1322,9 +1349,10 @@ class Solver {
   double eps_ = 0.0;
   MatrixXd Mt_;
   VectorXd scale_, hi_, d_, v_, u_, uS_, mu_, x_, xc_, lam_full_;
-  // Scratch: Ruiz factors, a user-frame / unscaled n-vector, the columns
-  // update_rows re-solves, and the rows refactor_working_set re-adds.
-  VectorXd fx_, fr_, xu_;
+  // Scratch: Ruiz factors, a user-frame / unscaled n-vector, the inverse
+  // iteration vector, the columns update_rows re-solves, and the rows
+  // refactor_working_set re-adds.
+  VectorXd fx_, fr_, xu_, eig_work_;
   MatrixXd changed_cols_;
   std::vector<int> changed_, rows_;
   std::vector<RowState> state_;

{elastiqp-0.2.0 → elastiqp-0.2.1}/include/elastiqp/elastiqp_c.h

@@ -74,7 +74,8 @@ typedef struct {
  * elastiqp_option_info() gives their ranges. Out-of-range values are rejected.
  *
  * Tolerances and iteration limits apply on the next solve. Scaling and
- * factorization options (ruiz*, zero_tol, eps_prox, reuse_factorization)
+ * factorization options (ruiz*, zero_tol, cond_iters, eps_prox,
+ * reuse_factorization)
  * apply on refactorization; updating Q forces it. Disabling ruiz retains
  * existing scaling. Explicit warm starts apply even with warm_start = 0.
  */
@@ -105,6 +106,8 @@ typedef struct {
 
   double relax_reg;
   int relax_factor_retries;
+
+  int cond_iters; /* appended to keep the struct layout of earlier fields */
 } ElastiQPSettings;
 
 /*

{elastiqp-0.2.0 → elastiqp-0.2.1}/package.xml

@@ -2,7 +2,7 @@
 <?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="3">
   <name>elastiqp</name>
-  <version>0.2.0</version>
+  <version>0.2.1</version>
   <description>ElastiQP: An elastic QP solver for robot control</description>
   <maintainer email="danielpmorton@gmail.com">Daniel Morton</maintainer>
   <license>Apache 2.0</license>

{elastiqp-0.2.0 → elastiqp-0.2.1}/python/elastiqp/jax.py

@@ -8,7 +8,7 @@ Supported:
 Notes:
 - vmap is sequential mode
 - Requires float64
-- Warm-starting is not differentiable
+- Warm-starting is differentiable (the warm start itself gets a zero gradient)
 - Warm-starting requires explicit passing of the previous result
 - Recommended default kappa for differentiability: 1e-3
 """
@@ -66,11 +66,6 @@ _lib = ctypes.cdll.LoadLibrary(str(_find_library()))
 jax.ffi.register_ffi_target(
     "elastiqp_solve", jax.ffi.pycapsule(_lib.ElastiqpSolve), platform="cpu"
 )
-jax.ffi.register_ffi_target(
-    "elastiqp_solve_warm",
-    jax.ffi.pycapsule(_lib.ElastiqpSolveWarm),
-    platform="cpu",
-)
 
 
 class Result(NamedTuple):
@@ -91,10 +86,14 @@ def _ffi_solve(
     G,
     h,
     penalty,
+    x0,
+    y0,
+    z0,
     eps_abs,
     max_iter,
     ruiz,
     target_kappa,
+    warm,
     method,
 ):
     n = Q.shape[-1]
@@ -105,60 +104,9 @@ def _ffi_solve(
     # (x, t, y, z_t, z) tight solution, then the kappa-relaxed central
     # point (identical to the tight block when target_kappa <= 0), then
     # info = [converged, iters, relax_converged].
-    out_types = [
-        vec(n),
-        vec(p),
-        vec(m),
-        vec(p),
-        vec(p),
-        vec(n),
-        vec(p),
-        vec(m),
-        vec(p),
-        vec(p),
-        vec(3),
-    ]
+    sol = [vec(n), vec(p), vec(m), vec(p), vec(p)]
+    out_types = sol + sol + [vec(3)]
     call = jax.ffi.ffi_call("elastiqp_solve", out_types, vmap_method="sequential")
-    return call(
-        Q,
-        q,
-        A,
-        b,
-        G,
-        h,
-        penalty,
-        eps_abs=np.float64(eps_abs),
-        max_iter=np.int64(max_iter),
-        ruiz=np.int64(bool(ruiz)),
-        target_kappa=np.float64(target_kappa),
-        method=np.int64(_METHOD_ID[method]),
-    )
-
-
-def _ffi_solve_warm(
-    Q,
-    q,
-    A,
-    b,
-    G,
-    h,
-    penalty,
-    x0,
-    y0,
-    z0,
-    eps_abs,
-    max_iter,
-    ruiz,
-    method,
-):
-    n = Q.shape[-1]
-    m = b.shape[-1]
-    p = h.shape[-1]
-    batch = Q.shape[:-2]
-    vec = lambda d: jax.ShapeDtypeStruct(batch + (d,), jnp.float64)
-    # (x, t, y, z_t, z), then info = [converged, iters].
-    out_types = [vec(n), vec(p), vec(m), vec(p), vec(p), vec(2)]
-    call = jax.ffi.ffi_call("elastiqp_solve_warm", out_types, vmap_method="sequential")
     return call(
         Q,
         q,
@@ -173,56 +121,12 @@ def _ffi_solve_warm(
         eps_abs=np.float64(eps_abs),
         max_iter=np.int64(max_iter),
         ruiz=np.int64(bool(ruiz)),
+        target_kappa=np.float64(target_kappa),
+        warm=np.int64(bool(warm)),
         method=np.int64(_METHOD_ID[method]),
     )
 
 
-@partial(jax.custom_vjp, nondiff_argnums=(10, 11, 12, 13))
-def _solve_warm(
-    Q,
-    q,
-    A,
-    b,
-    G,
-    h,
-    penalty,
-    x0,
-    y0,
-    z0,
-    eps_abs,
-    max_iter,
-    ruiz,
-    method,
-):
-    return _ffi_solve_warm(
-        Q,
-        q,
-        A,
-        b,
-        G,
-        h,
-        penalty,
-        x0,
-        y0,
-        z0,
-        eps_abs,
-        max_iter,
-        ruiz,
-        method,
-    )
-
-
-def _solve_warm_fwd(*args):
-    raise TypeError("elastiqp.jax.solve is not differentiable with warm_start")
-
-
-def _solve_warm_bwd(*args):
-    raise TypeError("elastiqp.jax.solve is not differentiable with warm_start")
-
-
-_solve_warm.defvjp(_solve_warm_fwd, _solve_warm_bwd)
-
-
 def _outer(a, b):
     return a[..., :, None] * b[..., None, :]
 
@@ -275,7 +179,9 @@ def _kkt_bwd(res, ct):
     return Qb, qb, Ab, bb, Gb, hb, penalty_b
 
 
-@partial(jax.custom_vjp, nondiff_argnums=(7, 8, 9, 10, 11))
+# target_kappa is only used by _solve_fwd; custom_vjp needs the primal and
+# fwd signatures to match. (x0, y0, z0) are ignored unless warm.
+@partial(jax.custom_vjp, nondiff_argnums=(10, 11, 12, 13, 14, 15))
 def _solve(
     Q,
     q,
@@ -284,10 +190,14 @@ def _solve(
     G,
     h,
     penalty,
+    x0,
+    y0,
+    z0,
     eps_abs,
     max_iter,
     ruiz,
     target_kappa,
+    warm,
     method,
 ):
     # Tight solution when not differentiating
@@ -299,10 +209,14 @@ def _solve(
         G,
         h,
         penalty,
+        x0,
+        y0,
+        z0,
         eps_abs,
         max_iter,
         ruiz,
         0.0,
+        warm,
         method,
     )
     return tuple(out[:5]) + (out[10],)  # solution + info
@@ -316,10 +230,14 @@ def _solve_fwd(
     G,
     h,
     penalty,
+    x0,
+    y0,
+    z0,
     eps_abs,
     max_iter,
     ruiz,
     target_kappa,
+    warm,
     method,
 ):
     if not target_kappa > 0:
@@ -335,18 +253,27 @@ def _solve_fwd(
         G,
         h,
         penalty,
+        x0,
+        y0,
+        z0,
         eps_abs,
         max_iter,
         ruiz,
         target_kappa,
+        warm,
         method,
     )
     x, t, y, z_t, z, xr, tr, yr, z_t_r, z_r, info = out
     return (x, t, y, z_t, z, info), (Q, A, G, h, xr, tr, yr, z_t_r, z_r)
 
 
-def _solve_bwd(eps_abs, max_iter, ruiz, target_kappa, method, res, ct):
-    return _kkt_bwd(res, ct)
+def _solve_bwd(eps_abs, max_iter, ruiz, target_kappa, warm, method, res, ct):
+    # Zero cotangent for the warm start: a converged solve of a QP with a
+    # unique solution does not depend on where the solver starts. The
+    # (x, y, z) cotangents share the (x0, y0, z0) shapes.
+    xb, _, yb, _, zb, _ = ct
+    zeros = (jnp.zeros_like(xb), jnp.zeros_like(yb), jnp.zeros_like(zb))
+    return _kkt_bwd(res, ct) + zeros
 
 
 _solve.defvjp(_solve_fwd, _solve_bwd)
@@ -396,7 +323,9 @@ def solve(
             derivatives. Defaults to 1e-3.
         warm_start (tuple | Result, optional): Explicit warm start, either a
             previous Result or a (x, y, z) tuple, (das and pdal only).
-            Defaults to None.
+            Differentiable: the gradients are the cold solve's, and the warm
+            start itself gets a zero gradient (exact when the QP has a unique
+            solution and the solve converges). Defaults to None.
 
     Returns:
         Result: Solution to the elastic QP
@@ -447,32 +376,11 @@ def solve(
                 f"{q.shape}, {b.shape}, {h.shape}; got "
                 f"{x0.shape}, {y0.shape}, {z0.shape}"
             )
-        x, t, y, z_t, z, info = _solve_warm(
-            Q,
-            q,
-            A,
-            b,
-            G,
-            h,
-            penalty,
-            x0,
-            y0,
-            z0,
-            float(eps_abs),
-            int(max_iter),
-            bool(ruiz),
-            method,
-        )
-        return Result(
-            x=x,
-            t=t,
-            y=y,
-            z_t=z_t,
-            z=z,
-            converged=info[..., 0].astype(jnp.int32),
-            iters=info[..., 1].astype(jnp.int32),
-        )
-
+    else:
+        # Ignored by the solver (warm=False)
+        x0 = jnp.zeros(q.shape, jnp.float64)
+        y0 = jnp.zeros(b.shape, jnp.float64)
+        z0 = jnp.zeros(h.shape, jnp.float64)
     x, t, y, z_t, z, info = _solve(
         Q,
         q,
@@ -481,10 +389,14 @@ def solve(
         G,
         h,
         penalty,
+        x0,
+        y0,
+        z0,
         float(eps_abs),
         int(max_iter),
         bool(ruiz),
         float(target_kappa),
+        warm_start is not None,
         method,
     )
     # Recall: info = [converged, iters, relax_converged]. The converged

{elastiqp-0.2.0 → elastiqp-0.2.1}/src/elastiqp_c.cc

@@ -120,8 +120,8 @@ constexpr Option kOptions[] = {
     ELASTIQP_D(sing_tol, 0.0,
                "Working-set LDL' pivot below this = dependent row."),
     ELASTIQP_D(zero_tol, 0.0,
-               "Min/max Cholesky pivot ratio of Q_s accepted before adding "
-               "a prox shift."),
+               "Min/max eigenvalue ratio of Q_s (from its Cholesky pivots, "
+               "see cond_iters) accepted before adding a prox shift."),
     ELASTIQP_D(eps_prox, 0.0,
                "Initial prox shift (x max|diag Q_s|) when Q_s is not PD; 0 "
                "disables."),
@@ -159,6 +159,10 @@ constexpr Option kOptions[] = {
     ELASTIQP_I(relax_factor_retries,
                "relax(): x100 regularization retries on a failed "
                "factorization."),
+    ELASTIQP_I(cond_iters,
+               "Inverse-iteration steps confirming the smallest eigenvalue "
+               "of Q_s against zero_tol when the pivots look small; 0: "
+               "pivots only."),
 };
 
 #undef ELASTIQP_D

{elastiqp-0.2.0 → elastiqp-0.2.1}/tests/test_c_api.c

@@ -286,7 +286,7 @@ static void options(void) {
   int i, j, type = -1, ok = 1, unique = 1, n_opt = elastiqp_num_options();
 
   elastiqp_setup(&work, &qp, NULL);
-  check("options: 22 listed", n_opt == 22);
+  check("options: 23 listed", n_opt == 23);
   for (i = 0; i < n_opt; ++i) {
     ok &= elastiqp_option_info(i, &name, &type, &def, &lo, &hi, &desc) == 0;
     ok &= name != NULL && desc != NULL && desc[0] != '\0';

{elastiqp-0.2.0 → elastiqp-0.2.1}/tests/test_c_parity.cc

@@ -215,6 +215,7 @@ void SettingsTable() {
   FIELD(refactor_tol);
   FIELD(relax_reg);
   FIELD(relax_factor_retries);
+  FIELD(cond_iters);
 #undef FIELD
   elastiqp_free(work);
   Check("option table covers every settings field",

{elastiqp-0.2.0 → elastiqp-0.2.1}/tests/test_das.cc

@@ -14,9 +14,10 @@
 // 3. Robustness: a badly scaled parametrization with and without Ruiz;
 //    dependent / inconsistent equalities (certificate before iterating);
 //    every inequality row duplicated (dependent working sets, the cycle
-//    guard's regime, refactors()); the drift-gated Ruiz refresh through a
-//    row exploding past the limit_scaling clamp and a row decaying to the
-//    noise floor.
+//    guard's regime, refactors()); a near-singular Q the Cholesky pivots
+//    hide (the eigenvalue check, and the prox fallback without it); the
+//    drift-gated Ruiz refresh through a row exploding past the
+//    limit_scaling clamp and a row decaying to the noise floor.
 // 4. Factorization reuse: constant Q, a fifth of G changing per tick,
 //    same answers as a full refactorization and only those rows re-solved.
 // 5. The pinch/release ticks of test_gap_creep: saturated -> active ->
@@ -294,6 +295,58 @@ void ProxLoop(std::mt19937& rng) {
         "status");
 }
 
+// Near-singular Q whose null direction is small on the trailing coordinates
+// (as in diff IK, J'J + 1e-12 I with 6 task rows on 7 DOF): the Cholesky
+// pivots overstate its smallest eigenvalue, so only the inverse-iteration
+// check turns the prox shift on up front. Without it (cond_iters = 0), the
+// inner loop can break down and must recover through the prox fallback.
+void NearSingularQ(std::mt19937& rng) {
+  const int n = 7, p = 14, cases = 20;
+  int solved = 0, prox = 0, escalated = 0;
+  int solved_off = 0, escalated_off = 0;
+  double worst = 0.0;
+  for (int k = 0; k < cases; ++k) {
+    VectorXd v = problem_gen::Randn(rng, n, 1);
+    v.tail(2) *= 0.05;
+    v.normalize();
+    const MatrixXd J = problem_gen::Randn(rng, n - 1, n) *
+                       (MatrixXd::Identity(n, n) - v * v.transpose());
+    const MatrixXd Q = J.transpose() * J + 1e-12 * MatrixXd::Identity(n, n);
+    const VectorXd q = -J.transpose() * problem_gen::Randn(rng, n - 1, 1);
+    MatrixXd G(p, n);
+    G << MatrixXd::Identity(n, n), -MatrixXd::Identity(n, n);
+    const VectorXd h = VectorXd::Constant(p, 0.5) +
+                       0.1 * problem_gen::Randn(rng, p, 1);
+    const VectorXd w = VectorXd::Constant(p, 1e3);
+    das::Solver s;
+    s.setup(Q, q, G, h, w);
+    const elastiqp::Solution sol = s.solve();
+    solved += sol.converged;
+    prox += s.proximal();
+    escalated += s.prox_escalated();
+    QPData qp;
+    qp.Q = Q;
+    qp.q = q;
+    qp.A = MatrixXd(0, n);
+    qp.b = VectorXd(0);
+    qp.G = G;
+    qp.h = h;
+    worst = std::max(worst, Kkt(qp, w, sol));
+    das::Solver off;
+    off.settings.cond_iters = 0;
+    off.setup(Q, q, G, h, w);
+    solved_off += off.solve().converged;
+    escalated_off += off.prox_escalated();
+  }
+  Check("near-singular Q: solved, prox on up front",
+        solved == cases && prox == cases && escalated == 0,
+        static_cast<double>(solved), "solved");
+  Check("near-singular Q: elastic KKT residual", worst <= 1e-6, worst, "kkt");
+  Check("near-singular Q, cond_iters = 0: solved via the prox fallback",
+        solved_off == cases && escalated_off > 0,
+        static_cast<double>(escalated_off), "escalated");
+}
+
 // Drift-gated Ruiz refresh through the update path: a row exploding past
 // the 1e4 clamp in one tick (rescaled() fires, drift back to O(1)) and a
 // row decaying to the noise floor (left alone, solved as if absent).
@@ -470,6 +523,7 @@ void RandomSuite() {
   EqualityCases(rng);
   DegenerateCase(rng);
   ProxLoop(rng);
+  NearSingularQ(rng);
   RuizRefresh(rng);
   ReuseBench();
 }

{elastiqp-0.2.0 → elastiqp-0.2.1}/tests/test_jax_ffi.py

@@ -14,6 +14,29 @@ import numpy as np
 RESULTS = []
 
 
+def ffi_solve_cold(
+    Q, q, A, b, G, h, penalty, eps_abs, max_iter, ruiz, target_kappa, method
+):
+    # Raw FFI call without a warm start (x0, y0, z0 are ignored placeholders)
+    zeros = (jnp.zeros_like(q), jnp.zeros_like(b), jnp.zeros_like(h))
+    return elastiqp.jax._ffi_solve(
+        Q,
+        q,
+        A,
+        b,
+        G,
+        h,
+        penalty,
+        *zeros,
+        eps_abs,
+        max_iter,
+        ruiz,
+        target_kappa,
+        False,
+        method,
+    )
+
+
 def check(name, ok, detail=""):
     RESULTS.append(ok)
     print(f"  {name:<52s} {detail:<24s} {'OK' if ok else 'FAIL'}")
@@ -198,7 +221,7 @@ def main():
         return w_loss @ s.x + w_t @ s.t
 
     def loss_relaxed(Q_, q_, A_, b_, G_, h_, penalty_, kap=kappa, method="das"):
-        out = elastiqp.jax._ffi_solve(
+        out = ffi_solve_cold(
             Q_,
             q_,
             A_,
@@ -317,7 +340,7 @@ def main():
     # relaxation would otherwise mean silently wrong gradients). s_t = t and
     # s_in = h + t - Gx are the slacks of t >= 0 and Gx - t <= h; s_in is
     # reconstructed from x, so it carries the O(tol) primal residual.
-    out = elastiqp.jax._ffi_solve(*args, 1e-11, 300, False, kappa, "das")
+    out = ffi_solve_cold(*args, 1e-11, 300, False, kappa, "das")
     xr, tr, z_t_r, z_r, info = out[5], out[6], out[8], out[9], out[10]
     s_in_r = args[5] + tr - args[4] @ xr
     comp = max(
@@ -334,7 +357,7 @@ def main():
     # silently: an absurd kappa converges the solve (info[0]) but stalls the
     # relaxation (info[2]), and solve() folds that into converged on the
     # differentiated path.
-    out = elastiqp.jax._ffi_solve(*args, 1e-11, 300, False, 1e8, "das")
+    out = ffi_solve_cold(*args, 1e-11, 300, False, 1e8, "das")
     tight_ok, relax_bad = float(out[10][0]) == 1.0, float(out[10][2]) == 0.0
 
     def conv_smooth(q_):
@@ -468,9 +491,7 @@ def main():
     try:
         jax.grad(
             lambda q_: jnp.sum(
-                elastiqp.jax.solve(
-                    Qx, q_, Gx, hx, 10.0, A=Ax, b=bx, target_kappa=0.0
-                ).x
+                elastiqp.jax.solve(Qx, q_, Gx, hx, 10.0, A=Ax, b=bx, target_kappa=0.0).x
             )
         )(qx)
         msg = None
@@ -517,7 +538,7 @@ def main():
         for m in elastiqp.jax.METHODS
     }
     relaxed = {
-        m: elastiqp.jax._ffi_solve(*args, 1e-11, 300, False, kappa, m)
+        m: ffi_solve_cold(*args, 1e-11, 300, False, kappa, m)
         for m in elastiqp.jax.METHODS
     }
     for m in ("pdal", "ipm"):
@@ -566,9 +587,9 @@ def main():
         int(a_sol.converged) == 1 and da < FFI_NB_TOL,
         f"|dx|={da:.1e}",
     )
-    a_jit = jax.jit(
-        lambda q_: elastiqp.jax.solve(Qx, q_, Gx, hx, 10.0, A=Ax, b=bx).x
-    )(qx)
+    a_jit = jax.jit(lambda q_: elastiqp.jax.solve(Qx, q_, Gx, hx, 10.0, A=Ax, b=bx).x)(
+        qx
+    )
     check("das under jit", float(jnp.abs(a_jit - a_sol.x).max()) == 0.0, "")
     # Hard rows (penalty = inf, das only): finite gradients, none w.r.t. the
     # hard row's penalty, close to a stiff elastic penalty in its place.
@@ -671,8 +692,15 @@ def main():
     check("warm sequence has working-set changes", ws_changed > 0, f"{ws_changed}")
     try:
         elastiqp.jax.solve(
-            Qw, drift[0][0], Gw, drift[0][1], 10.0, A=Aw, b=drift[0][2],
-            method="ipm", warm_start=prev,
+            Qw,
+            drift[0][0],
+            Gw,
+            drift[0][1],
+            10.0,
+            A=Aw,
+            b=drift[0][2],
+            method="ipm",
+            warm_start=prev,
         )
         ipm_raised = False
     except ValueError:
@@ -755,22 +783,57 @@ def main():
         f"|dx|={dxv:.1e} max iters={int(v_warm.iters.max())}",
     )
 
-    try:
-        jax.grad(
-            lambda q_: jnp.sum(
-                elastiqp.jax.solve(
-                    Qw, q_, Gw, h_k, 10.0, A=Aw, b=b_k, warm_start=p_sol
-                ).x
+    # A warm-started solve has the cold solve's gradients (the solution does
+    # not depend on the start), and a zero gradient for the warm start itself
+    def loss_w(Q_, q_, G_, h_, pen_, warm, method):
+        s = elastiqp.jax.solve(
+            Q_, q_, G_, h_, pen_, A=Aw, b=b_k, method=method, warm_start=warm
+        )
+        return jnp.sum(s.x**2) + jnp.sum(jnp.sin(s.x))
+
+    pen_k = jnp.full(h_k.shape, 10.0)
+    warm = (p_sol.x, p_sol.y, p_sol.z)
+    for method in ("das", "pdal"):
+        g_cold = jax.grad(loss_w, argnums=(0, 1, 2, 3, 4))(
+            Qw, q_k, Gw, h_k, pen_k, None, method
+        )
+        *g_warm, g_start = jax.grad(loss_w, argnums=(0, 1, 2, 3, 4, 5))(
+            Qw, q_k, Gw, h_k, pen_k, warm, method
+        )
+        dg = max(
+            float(jnp.abs(a - b).max()) for a, b in zip(g_cold, g_warm, strict=True)
+        )
+        g0 = max(float(jnp.abs(g).max()) for g in g_start)
+        check(
+            f"grad with warm_start ({method}) == cold",
+            dg < 1e-8 and g0 == 0.0,
+            f"|dgrad|={dg:.1e} |grad warm start|={g0:.1e}",
+        )
+
+    # Warm-started lax.scan works under jit + grad and matches the cold scan.
+    # The carry's cotangent is zero by construction, so this is a smoke test
+    # of the warm path, not an independent check of the gradient through it
+    def scan_loss(q_, warm_carry):
+        def body(carry, h_):
+            s = elastiqp.jax.solve(
+                Qw,
+                q_,
+                Gw,
+                h_,
+                10.0,
+                A=Aw,
+                b=b_k,
+                warm_start=carry if warm_carry else None,
             )
-        )(q_k)
-        msg = None
-    except TypeError as e:
-        msg = str(e)
-    check(
-        "grad with warm_start raises",
-        msg is not None and "warm_start" in msg and "not differentiable" in msg,
-        "",
-    )
+            return (s.x, s.y, s.z), jnp.sum(s.x**2)
+
+        _, losses = jax.lax.scan(body, warm, hs)
+        return jnp.sum(losses)
+
+    g_cold = jax.jit(jax.grad(scan_loss), static_argnums=1)(q_k, False)
+    g_warm = jax.jit(jax.grad(scan_loss), static_argnums=1)(q_k, True)
+    dgs = float(jnp.abs(g_cold - g_warm).max())
+    check("grad through a warm-started lax.scan", dgs < 1e-8, f"|dgrad|={dgs:.1e}")
     try:
         elastiqp.jax.solve(
             Qw,
@@ -825,8 +888,15 @@ def main():
 
     def x0_of_h0(h0, method):
         return elastiqp.jax.solve(
-            Qb, qb, Gb, hb.at[0].set(h0), 10.0, A=Ab, b=bb,
-            method=method, target_kappa=1e-9,
+            Qb,
+            qb,
+            Gb,
+            hb.at[0].set(h0),
+            10.0,
+            A=Ab,
+            b=bb,
+            method=method,
+            target_kappa=1e-9,
         ).x[0]
 
     for method in ["das", "pdal", "ipm"]: