sleipnirgroup-jormungandr 0.5.6.dev13__tar.gz → 0.5.6.dev14__tar.gz

{sleipnirgroup_jormungandr-0.5.6.dev13 → sleipnirgroup_jormungandr-0.5.6.dev14}/PKG-INFO

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

{sleipnirgroup_jormungandr-0.5.6.dev13 → sleipnirgroup_jormungandr-0.5.6.dev14}/include/sleipnir/optimization/solver/interior_point.hpp

@@ -580,6 +580,7 @@ ExitStatus interior_point(
                   trial_c_e.template lpNorm<1>() +
                       (trial_c_i - trial_s).template lpNorm<1>(),
                   trial_s.dot(trial_z), μ, solver.hessian_regularization(),
+                  solver.constraint_jacobian_regularization(),
                   std::max(soc_step.p_x.template lpNorm<Eigen::Infinity>(),
                            soc_step.p_s.template lpNorm<Eigen::Infinity>()),
                   std::max(soc_step.p_y.template lpNorm<Eigen::Infinity>(),
@@ -817,6 +818,7 @@ ExitStatus interior_point(
           inner_iter_profiler.current_duration(), E_0, f,
           c_e.template lpNorm<1>() + (c_i - s).template lpNorm<1>(), s.dot(z),
           μ, solver.hessian_regularization(),
+          solver.constraint_jacobian_regularization(),
           std::max(step.p_x.template lpNorm<Eigen::Infinity>(),
                    step.p_s.template lpNorm<Eigen::Infinity>()),
           std::max(step.p_y.template lpNorm<Eigen::Infinity>(),

{sleipnirgroup_jormungandr-0.5.6.dev13 → sleipnirgroup_jormungandr-0.5.6.dev14}/include/sleipnir/optimization/solver/newton.hpp

@@ -267,6 +267,7 @@ ExitStatus newton(
           iterations, IterationType::NORMAL,
           inner_iter_profiler.current_duration(), E_0, f, Scalar(0), Scalar(0),
           Scalar(0), solver.hessian_regularization(),
+          solver.constraint_jacobian_regularization(),
           p_x.template lpNorm<Eigen::Infinity>(), Scalar(1), α, α_max,
           α_reduction_factor, Scalar(1));
     }

{sleipnirgroup_jormungandr-0.5.6.dev13 → sleipnirgroup_jormungandr-0.5.6.dev14}/include/sleipnir/optimization/solver/sqp.hpp

@@ -403,6 +403,7 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
                       g, A_e, trial_c_e, trial_y),
                   trial_f, trial_c_e.template lpNorm<1>(), Scalar(0), Scalar(0),
                   solver.hessian_regularization(),
+                  solver.constraint_jacobian_regularization(),
                   soc_step.p_x.template lpNorm<Eigen::Infinity>(),
                   soc_step.p_y.template lpNorm<Eigen::Infinity>(), α_soc,
                   Scalar(1), α_reduction_factor, Scalar(1));
@@ -572,6 +573,7 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
                                   inner_iter_profiler.current_duration(), E_0,
                                   f, c_e.template lpNorm<1>(), Scalar(0),
                                   Scalar(0), solver.hessian_regularization(),
+                                  solver.constraint_jacobian_regularization(),
                                   step.p_x.template lpNorm<Eigen::Infinity>(),
                                   step.p_y.template lpNorm<Eigen::Infinity>(),
                                   α, α_max, α_reduction_factor, α);

{sleipnirgroup_jormungandr-0.5.6.dev13 → sleipnirgroup_jormungandr-0.5.6.dev14}/include/sleipnir/optimization/solver/util/dense_regularized_ldlt.hpp

@@ -68,6 +68,7 @@ class DenseRegularizedLDLT {
       if (Inertia{D} == ideal_inertia &&
           (D.cwiseAbs().array() >= Scalar(1e-4)).all()) {
         m_prev_δ = Scalar(0);
+        m_prev_γ = Scalar(0);
         return *this;
       }
     }
@@ -88,6 +89,7 @@ class DenseRegularizedLDLT {
         if (inertia == ideal_inertia) {
           // If the inertia is ideal, report success
           m_prev_δ = δ;
+          m_prev_γ = γ;
           return *this;
         } else if (inertia.zero > 0) {
           if (γ == Scalar(0)) {
@@ -115,6 +117,8 @@ class DenseRegularizedLDLT {
       // caused by ill-conditioning.
       if (δ > Scalar(1e20) || γ > Scalar(1e20)) {
         m_info = Eigen::NumericalIssue;
+        m_prev_δ = δ;
+        m_prev_γ = γ;
         return *this;
       }
     }
@@ -143,6 +147,11 @@ class DenseRegularizedLDLT {
   /// @return Hessian regularization factor.
   Scalar hessian_regularization() const { return m_prev_δ; }
 
+  /// Returns the constraint Jacobian regularization factor.
+  ///
+  /// @return Constraint Jacobian regularization factor.
+  Scalar constraint_jacobian_regularization() const { return m_prev_γ; }
+
  private:
   using Solver = Eigen::LDLT<DenseMatrix>;
 
@@ -166,6 +175,9 @@ class DenseRegularizedLDLT {
   /// The value of δ from the previous run of compute().
   Scalar m_prev_δ{0};
 
+  /// The value of γ from the previous run of compute().
+  Scalar m_prev_γ{0};
+
   /// Returns regularization matrix.
   ///
   ///   [δI    0]

{sleipnirgroup_jormungandr-0.5.6.dev13 → sleipnirgroup_jormungandr-0.5.6.dev14}/include/sleipnir/optimization/solver/util/regularized_ldlt.hpp

@@ -116,6 +116,17 @@ class RegularizedLDLT {
     }
   }
 
+  /// Returns the constraint Jacobian regularization factor.
+  ///
+  /// @return Constraint Jacobian regularization factor.
+  Scalar constraint_jacobian_regularization() const {
+    if (m_use_sparse_solver) {
+      return m_sparse_solver.constraint_jacobian_regularization();
+    } else {
+      return m_dense_solver.constraint_jacobian_regularization();
+    }
+  }
+
  private:
   bool m_use_sparse_solver;
   SparseRegularizedLDLT<Scalar> m_sparse_solver;

{sleipnirgroup_jormungandr-0.5.6.dev13 → sleipnirgroup_jormungandr-0.5.6.dev14}/include/sleipnir/optimization/solver/util/sparse_regularized_ldlt.hpp

@@ -83,6 +83,7 @@ class SparseRegularizedLDLT {
       if (Inertia{D} == ideal_inertia &&
           (D.cwiseAbs().array() >= Scalar(1e-4)).all()) {
         m_prev_δ = Scalar(0);
+        m_prev_γ = Scalar(0);
         return *this;
       }
     }
@@ -104,6 +105,7 @@ class SparseRegularizedLDLT {
         if (inertia == ideal_inertia) {
           // If the inertia is ideal, report success
           m_prev_δ = δ;
+          m_prev_γ = γ;
           return *this;
         } else if (inertia.zero > 0) {
           if (γ == Scalar(0)) {
@@ -131,6 +133,8 @@ class SparseRegularizedLDLT {
       // caused by ill-conditioning.
       if (δ > Scalar(1e20) || γ > Scalar(1e20)) {
         m_info = Eigen::NumericalIssue;
+        m_prev_δ = δ;
+        m_prev_γ = γ;
         return *this;
       }
     }
@@ -159,6 +163,11 @@ class SparseRegularizedLDLT {
   /// @return Hessian regularization factor.
   Scalar hessian_regularization() const { return m_prev_δ; }
 
+  /// Returns the constraint Jacobian regularization factor.
+  ///
+  /// @return Constraint Jacobian regularization factor.
+  Scalar constraint_jacobian_regularization() const { return m_prev_γ; }
+
  private:
   using Solver = Eigen::SimplicialLDLT<SparseMatrix>;
 
@@ -183,6 +192,9 @@ class SparseRegularizedLDLT {
   /// The value of δ from the previous run of compute().
   Scalar m_prev_δ{0};
 
+  /// The value of γ from the previous run of compute().
+  Scalar m_prev_γ{0};
+
   /// Returns regularization matrix.
   ///
   ///   [δI    0]

{sleipnirgroup_jormungandr-0.5.6.dev13 → sleipnirgroup_jormungandr-0.5.6.dev14}/include/sleipnir/util/print_diagnostics.hpp

@@ -182,6 +182,7 @@ inline void print_bound_constraint_global_infeasibility_error(
 /// @param complementarity The complementarity.
 /// @param μ The barrier parameter.
 /// @param δ The Hessian regularization factor.
+/// @param γ The constraint Jacobian regularization factor.
 /// @param full_primal_step_inf_norm The infinity norm of the full primal step.
 /// @param full_dual_step_inf_norm The infinity norm of the full dual step.
 /// @param primal_α The primal step size.
@@ -194,23 +195,23 @@ void print_iteration_diagnostics(int iterations, IterationType type,
                                  const std::chrono::duration<Rep, Period>& time,
                                  Scalar error, Scalar cost,
                                  Scalar infeasibility, Scalar complementarity,
-                                 Scalar μ, Scalar δ,
+                                 Scalar μ, Scalar δ, Scalar γ,
                                  Scalar full_primal_step_inf_norm,
                                  Scalar full_dual_step_inf_norm,
                                  Scalar primal_α, Scalar primal_α_max,
                                  Scalar α_reduction_factor, Scalar dual_α) {
   if (iterations % 20 == 0) {
     if (iterations == 0) {
-      slp::println("┏{:━^116}┓", "");
+      slp::println("┏{:━^122}┓", "");
     } else {
-      slp::println("┢{:━^116}┪", "");
+      slp::println("┢{:━^122}┪", "");
     }
     slp::println(
-        "┃{:^4} {:^4} {:^9} {:^10} {:^11} {:^10} {:^8} {:^8} {:^5} {:^8} {:^8} "
-        "{:^8} {:^8} {:^2}┃",
+        "┃{:^4} {:^4} {:^9} {:^10} {:^11} {:^10} {:^8} {:^8} {:^5} {:^5} {:^8} "
+        "{:^8} {:^8} {:^8} {:^2}┃",
         "iter", "type", "duration", "error", "cost", "infeas.", "complem.", "μ",
-        "δ", "|p_pr|", "|p_du|", "α_pr", "α_du", "↩");
-    slp::println("┡{:━^116}┩", "");
+        "δ", "γ", "|p_pr|", "|p_du|", "α_pr", "α_du", "↩");
+    slp::println("┡{:━^122}┩", "");
   }
 
   // For the number of backtracks, we want x such that:
@@ -229,10 +230,10 @@ void print_iteration_diagnostics(int iterations, IterationType type,
 
   constexpr std::array ITERATION_TYPES{"norm", "✓SOC", "XSOC", "rest"};
   slp::println(
-      "│{:4} {:4} {:9.3f} {:.4e} {:11.4e} {:.4e} {:.2e} {:.2e} {:<5} {:.2e} "
-      "{:.2e} {:.2e} {:.2e} {:2d}│",
+      "│{:4} {:4} {:9.3f} {:.4e} {:11.4e} {:.4e} {:.2e} {:.2e} {:<5} {:<5} "
+      "{:.2e} {:.2e} {:.2e} {:.2e} {:2d}│",
       iterations, ITERATION_TYPES[std::to_underlying(type)], to_ms(time), error,
-      cost, infeasibility, complementarity, μ, power_of_10(δ),
+      cost, infeasibility, complementarity, μ, power_of_10(δ), power_of_10(γ),
       full_primal_step_inf_norm, full_dual_step_inf_norm, primal_α, dual_α,
       backtracks);
 }
@@ -243,7 +244,7 @@ void print_iteration_diagnostics(int iterations, IterationType type,
 #ifndef SLEIPNIR_DISABLE_DIAGNOSTICS
 /// Prints bottom of iteration diagnostics table.
 inline void print_bottom_iteration_diagnostics() {
-  slp::println("└{:─^116}┘", "");
+  slp::println("└{:─^122}┘", "");
 }
 #else
 #define print_bottom_iteration_diagnostics(...)

{sleipnirgroup_jormungandr-0.5.6.dev13 → sleipnirgroup_jormungandr-0.5.6.dev14}/python/src/sleipnir/__init__.py

@@ -2,4 +2,4 @@
 
 from ._sleipnir import *
 
-__version__ = "0.5.6.dev13"
+__version__ = "0.5.6.dev14"