sleipnirgroup-jormungandr 0.5.6.dev20__tar.gz → 0.5.6.dev22__tar.gz

{sleipnirgroup_jormungandr-0.5.6.dev20 → sleipnirgroup_jormungandr-0.5.6.dev22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sleipnirgroup-jormungandr
-Version: 0.5.6.dev20
+Version: 0.5.6.dev22
 Summary: Reverse mode autodiff library and NLP solver DSL
 License-Expression: BSD-3-Clause
 License-File: LICENSE.txt

{sleipnirgroup_jormungandr-0.5.6.dev20 → sleipnirgroup_jormungandr-0.5.6.dev22}/include/sleipnir/optimization/solver/interior_point.hpp

@@ -77,12 +77,13 @@ ExitStatus interior_point(
   DenseVector z =
       DenseVector::Ones(matrix_callbacks.num_inequality_constraints);
   Scalar μ = Scalar(0.1) * matrix_callbacks.scaling.f;
+  int iterations = 0;
 
   return interior_point(matrix_callbacks, iteration_callbacks, options, false,
 #ifdef SLEIPNIR_ENABLE_BOUND_PROJECTION
                         bound_constraint_mask,
 #endif
-                        x, s, y, z, μ);
+                        x, s, y, z, μ, iterations);
 }
 
 /// Finds the optimal solution to a nonlinear program using the interior-point
@@ -116,6 +117,7 @@ ExitStatus interior_point(
 ///     constraint dual variables.
 /// @param[in,out] μ The initial guess and output location for the barrier
 ///     parameter.
+/// @param[in,out] iterations The iteration counter.
 /// @return The exit status.
 template <typename Scalar>
 ExitStatus interior_point(
@@ -129,7 +131,7 @@ ExitStatus interior_point(
     Eigen::Vector<Scalar, Eigen::Dynamic>& x,
     Eigen::Vector<Scalar, Eigen::Dynamic>& s,
     Eigen::Vector<Scalar, Eigen::Dynamic>& y,
-    Eigen::Vector<Scalar, Eigen::Dynamic>& z, Scalar& μ) {
+    Eigen::Vector<Scalar, Eigen::Dynamic>& z, Scalar& μ, int& iterations) {
   using DenseVector = Eigen::Vector<Scalar, Eigen::Dynamic>;
   using SparseMatrix = Eigen::SparseMatrix<Scalar>;
   using SparseVector = Eigen::SparseVector<Scalar>;
@@ -288,8 +290,6 @@ ExitStatus interior_point(
   s = bound_constraint_mask.select(c_i, s);
 #endif
 
-  int iterations = 0;
-
   // Barrier parameter minimum
   const Scalar μ_min =
       matrices.scaling.f * Scalar(options.tolerance) / Scalar(10);
@@ -733,8 +733,8 @@ ExitStatus interior_point(
                    Scalar(0.9) * initial_entry.constraint_violation &&
                filter.try_add(initial_entry, trial_entry, trial_x - x, g, α);
       });
-      auto status = feasibility_restoration<Scalar>(matrices, callbacks,
-                                                    options, x, s, y, z, μ);
+      auto status = feasibility_restoration<Scalar>(
+          matrices, callbacks, options, x, s, y, z, μ, iterations);
 
       if (status != ExitStatus::SUCCESS) {
         // Report failure

{sleipnirgroup_jormungandr-0.5.6.dev20 → sleipnirgroup_jormungandr-0.5.6.dev22}/include/sleipnir/optimization/solver/sqp.hpp

@@ -531,8 +531,8 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
                    Scalar(0.9) * initial_entry.constraint_violation &&
                filter.try_add(initial_entry, trial_entry, trial_x - x, g, α);
       });
-      auto status =
-          feasibility_restoration<Scalar>(matrices, callbacks, options, x, y);
+      auto status = feasibility_restoration<Scalar>(matrices, callbacks,
+                                                    options, x, y, iterations);
 
       if (status != ExitStatus::SUCCESS) {
         // Report failure

{sleipnirgroup_jormungandr-0.5.6.dev20 → sleipnirgroup_jormungandr-0.5.6.dev22}/include/sleipnir/optimization/solver/util/dense_regularized_ldlt.hpp

@@ -7,8 +7,6 @@
 
 #include "sleipnir/optimization/solver/util/inertia.hpp"
 
-// See docs/algorithms.md#Works_cited for citation definitions
-
 namespace slp {
 
 /// Solves dense systems of linear equations using a regularized LDLT
@@ -56,8 +54,6 @@ class DenseRegularizedLDLT {
   /// @param lhs Left-hand side of the system.
   /// @return The factorization.
   DenseRegularizedLDLT& compute(const DenseMatrix& lhs) {
-    // The regularization procedure is based on algorithm B.1 of [1]
-
     m_info = m_solver.compute(lhs).info();
 
     if (m_info == Eigen::Success) {
@@ -73,11 +69,15 @@ class DenseRegularizedLDLT {
       }
     }
 
-    // Also regularize the Hessian. If the Hessian wasn't regularized in a
-    // previous run of compute(), start at small values of δ and γ. Otherwise,
-    // attempt a δ and γ half as big as the previous run so δ and γ can trend
-    // downwards over time.
+    // We'll give lhs the correct inertia by adding [δI, 0; 0, −γI] where δ and
+    // γ regularize the Hessian and equality constraint Jacobian respectively.
+
+    // If the previous δ was zero, attempt a small value. Otherwise, attempt a
+    // smaller value than the previous δ so δ trends downward.
     Scalar δ = m_prev_δ == Scalar(0) ? Scalar(1e-4) : m_prev_δ / Scalar(2);
+
+    // Start γ at the minimum to minimize equality constraint Jacobian
+    // distortion.
     Scalar γ = m_γ_min;
 
     while (true) {
@@ -93,28 +93,33 @@ class DenseRegularizedLDLT {
           return *this;
         } else if (inertia.zero > 0) {
           if (γ == Scalar(0)) {
-            // If there's zero eigenvalues and γ = 0, increase γ
+            // If there's zero eigenvalues and γ = 0, increase γ to potentially
+            // compensate for a rank-deficient equality constraint Jacobian
             γ = Scalar(1e-10);
           } else {
-            // If there's zero eigenvalues and γ > 0, increase δ and γ
+            // If there's zero eigenvalues and γ > 0, increase δ and γ to drive
+            // all eigenvalues away from zero
             δ *= Scalar(10);
             γ *= Scalar(10);
           }
         } else if (inertia.negative > ideal_inertia.negative) {
-          // If there's too many negative eigenvalues, increase δ
+          // If there's too many negative eigenvalues, increase δ to add more
+          // positive eigenvalues
           δ *= Scalar(10);
         } else if (inertia.positive > ideal_inertia.positive) {
-          // If there's too many positive eigenvalues, increase γ
+          // If there's too many positive eigenvalues, increase γ to add more
+          // negative eigenvalues
           γ = γ == Scalar(0) ? Scalar(1e-10) : γ * Scalar(10);
         }
       } else {
-        // If the decomposition failed, increase δ and γ
+        // If the decomposition failed, increase δ and γ to drive all
+        // eigenvalues away from zero
         δ *= Scalar(10);
         γ = γ == Scalar(0) ? Scalar(1e-10) : γ * Scalar(10);
       }
 
-      // If the Hessian perturbation is too high, report failure. This can be
-      // caused by ill-conditioning.
+      // If the lhs perturbation is too high, report failure. This can be caused
+      // by ill-conditioning.
       if (δ > Scalar(1e20) || γ > Scalar(1e20)) {
         m_info = Eigen::NumericalIssue;
         m_prev_δ = δ;

{sleipnirgroup_jormungandr-0.5.6.dev20 → sleipnirgroup_jormungandr-0.5.6.dev22}/include/sleipnir/optimization/solver/util/feasibility_restoration.hpp

@@ -33,7 +33,7 @@ ExitStatus interior_point(
     Eigen::Vector<Scalar, Eigen::Dynamic>& x,
     Eigen::Vector<Scalar, Eigen::Dynamic>& s,
     Eigen::Vector<Scalar, Eigen::Dynamic>& y,
-    Eigen::Vector<Scalar, Eigen::Dynamic>& z, Scalar& μ);
+    Eigen::Vector<Scalar, Eigen::Dynamic>& z, Scalar& μ, int& iterations);
 
 /// Computes initial values for p and n in feasibility restoration.
 ///
@@ -109,6 +109,7 @@ compute_p_n(const Eigen::Vector<Scalar, Eigen::Dynamic>& c, Scalar ρ,
 /// @param[in,out] x The decision variables from the normal solve.
 /// @param[in,out] y The equality constraint dual variables from the normal
 ///     solve.
+/// @param[in,out] iterations The iteration counter.
 /// @return The exit status.
 template <typename Scalar>
 ExitStatus feasibility_restoration(
@@ -116,7 +117,7 @@ ExitStatus feasibility_restoration(
     std::span<std::function<bool(const IterationInfo<Scalar>& info)>>
         iteration_callbacks,
     const Options& options, Eigen::Vector<Scalar, Eigen::Dynamic>& x,
-    Eigen::Vector<Scalar, Eigen::Dynamic>& y) {
+    Eigen::Vector<Scalar, Eigen::Dynamic>& y, int& iterations) {
   // Feasibility restoration
   //
   //        min  ρ Σ (pₑ + nₑ) + ζ/2 (x - xᵣ)ᵀDᵣ(x - xᵣ)
@@ -297,12 +298,12 @@ ExitStatus feasibility_restoration(
       },
       fr_scaling};
 
-  auto status = interior_point<Scalar>(fr_matrix_callbacks, iteration_callbacks,
-                                       options, true,
+  auto status = interior_point<Scalar>(
+      fr_matrix_callbacks, iteration_callbacks, options, true,
 #ifdef SLEIPNIR_ENABLE_BOUND_PROJECTION
-                                       {},
+      {},
 #endif
-                                       fr_x, fr_s, fr_y, fr_z, fr_μ);
+      fr_x, fr_s, fr_y, fr_z, fr_μ, iterations);
 
   x = fr_x.segment(0, x.rows());
 
@@ -337,6 +338,7 @@ ExitStatus feasibility_restoration(
 /// @param[in,out] z The current inequality constraint duals from the normal
 ///     solve.
 /// @param[in] μ Barrier parameter.
+/// @param[in,out] iterations The iteration counter.
 /// @return The exit status.
 template <typename Scalar>
 ExitStatus feasibility_restoration(
@@ -346,7 +348,7 @@ ExitStatus feasibility_restoration(
     const Options& options, Eigen::Vector<Scalar, Eigen::Dynamic>& x,
     Eigen::Vector<Scalar, Eigen::Dynamic>& s,
     Eigen::Vector<Scalar, Eigen::Dynamic>& y,
-    Eigen::Vector<Scalar, Eigen::Dynamic>& z, Scalar μ) {
+    Eigen::Vector<Scalar, Eigen::Dynamic>& z, Scalar μ, int& iterations) {
   // Feasibility restoration
   //
   //        min  ρ Σ (pₑ + nₑ + pᵢ + nᵢ) + ζ/2 (x - xᵣ)ᵀDᵣ(x - xᵣ)
@@ -584,12 +586,12 @@ ExitStatus feasibility_restoration(
       },
       fr_scaling};
 
-  auto status = interior_point<Scalar>(fr_matrix_callbacks, iteration_callbacks,
-                                       options, true,
+  auto status = interior_point<Scalar>(
+      fr_matrix_callbacks, iteration_callbacks, options, true,
 #ifdef SLEIPNIR_ENABLE_BOUND_PROJECTION
-                                       {},
+      {},
 #endif
-                                       fr_x, fr_s, fr_y, fr_z, fr_μ);
+      fr_x, fr_s, fr_y, fr_z, fr_μ, iterations);
 
   x = fr_x.segment(0, x.rows());
   s = fr_s.segment(0, s.rows());

{sleipnirgroup_jormungandr-0.5.6.dev20 → sleipnirgroup_jormungandr-0.5.6.dev22}/include/sleipnir/optimization/solver/util/sparse_regularized_ldlt.hpp

@@ -8,8 +8,6 @@
 
 #include "sleipnir/optimization/solver/util/inertia.hpp"
 
-// See docs/algorithms.md#Works_cited for citation definitions
-
 namespace slp {
 
 /// Solves sparse systems of linear equations using a regularized LDLT
@@ -61,8 +59,6 @@ class SparseRegularizedLDLT {
   /// @param lhs Left-hand side of the system.
   /// @return The factorization.
   SparseRegularizedLDLT& compute(const SparseMatrix& lhs) {
-    // The regularization procedure is based on algorithm B.1 of [1]
-
     // Regularization with zeros ensures the pattern analysis in the sparse
     // solver is reused by all factorizations
     SparseMatrix unregularized_lhs = lhs + regularization(Scalar(0), Scalar(0));
@@ -88,11 +84,15 @@ class SparseRegularizedLDLT {
       }
     }
 
-    // Also regularize the Hessian. If the Hessian wasn't regularized in a
-    // previous run of compute(), start at small values of δ and γ. Otherwise,
-    // attempt a δ and γ half as big as the previous run so δ and γ can trend
-    // downwards over time.
+    // We'll give lhs the correct inertia by adding [δI, 0; 0, −γI] where δ and
+    // γ regularize the Hessian and equality constraint Jacobian respectively.
+
+    // If the previous δ was zero, attempt a small value. Otherwise, attempt a
+    // smaller value than the previous δ so δ trends downward.
     Scalar δ = m_prev_δ == Scalar(0) ? Scalar(1e-4) : m_prev_δ / Scalar(2);
+
+    // Start γ at the minimum to minimize equality constraint Jacobian
+    // distortion.
     Scalar γ = m_γ_min;
 
     while (true) {
@@ -109,28 +109,33 @@ class SparseRegularizedLDLT {
           return *this;
         } else if (inertia.zero > 0) {
           if (γ == Scalar(0)) {
-            // If there's zero eigenvalues and γ = 0, increase γ
+            // If there's zero eigenvalues and γ = 0, increase γ to potentially
+            // compensate for a rank-deficient equality constraint Jacobian
             γ = Scalar(1e-10);
           } else {
-            // If there's zero eigenvalues and γ > 0, increase δ and γ
+            // If there's zero eigenvalues and γ > 0, increase δ and γ to drive
+            // all eigenvalues away from zero
             δ *= Scalar(10);
             γ *= Scalar(10);
           }
         } else if (inertia.negative > ideal_inertia.negative) {
-          // If there's too many negative eigenvalues, increase δ
+          // If there's too many negative eigenvalues, increase δ to add more
+          // positive eigenvalues
           δ *= Scalar(10);
         } else if (inertia.positive > ideal_inertia.positive) {
-          // If there's too many positive eigenvalues, increase γ
+          // If there's too many positive eigenvalues, increase γ to add more
+          // negative eigenvalues
           γ = γ == Scalar(0) ? Scalar(1e-10) : γ * Scalar(10);
         }
       } else {
-        // If the decomposition failed, increase δ and γ
+        // If the decomposition failed, increase δ and γ to drive all
+        // eigenvalues away from zero
         δ *= Scalar(10);
         γ = γ == Scalar(0) ? Scalar(1e-10) : γ * Scalar(10);
       }
 
-      // If the Hessian perturbation is too high, report failure. This can be
-      // caused by ill-conditioning.
+      // If the lhs perturbation is too high, report failure. This can be caused
+      // by ill-conditioning.
       if (δ > Scalar(1e20) || γ > Scalar(1e20)) {
         m_info = Eigen::NumericalIssue;
         m_prev_δ = δ;

{sleipnirgroup_jormungandr-0.5.6.dev20 → sleipnirgroup_jormungandr-0.5.6.dev22}/python/src/sleipnir/__init__.py

@@ -2,4 +2,4 @@
 
 from ._sleipnir import *
 
-__version__ = "0.5.6.dev20"
+__version__ = "0.5.6.dev22"