sleipnirgroup-jormungandr 0.5.5.dev8__tar.gz → 0.5.6.dev4__tar.gz

{sleipnirgroup_jormungandr-0.5.5.dev8 → sleipnirgroup_jormungandr-0.5.6.dev4}/PKG-INFO

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

{sleipnirgroup_jormungandr-0.5.5.dev8 → sleipnirgroup_jormungandr-0.5.6.dev4}/include/sleipnir/autodiff/variable_matrix.hpp

@@ -1184,11 +1184,11 @@ class VariableMatrix : public SleipnirBase {
   /// @return Number of elements in matrix.
   size_t size() const { return m_storage.size(); }
 
-  /// Returns a variable matrix filled with zeroes.
+  /// Returns a variable matrix filled with zeros.
   ///
   /// @param rows The number of matrix rows.
   /// @param cols The number of matrix columns.
-  /// @return A variable matrix filled with zeroes.
+  /// @return A variable matrix filled with zeros.
   static VariableMatrix<Scalar> zero(int rows, int cols) {
     VariableMatrix<Scalar> result{detail::empty, rows, cols};
 

{sleipnirgroup_jormungandr-0.5.5.dev8 → sleipnirgroup_jormungandr-0.5.6.dev4}/include/sleipnir/optimization/solver/interior_point.hpp

@@ -566,6 +566,10 @@ 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(),
+                  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>(),
+                           soc_step.p_z.template lpNorm<Eigen::Infinity>()),
                   α_soc, Scalar(1), α_reduction_factor, α_z_soc);
             }
           }};
@@ -795,8 +799,12 @@ ExitStatus interior_point(
                                      : IterationType::NORMAL,
           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(), α, α_max, α_reduction_factor,
-          α_z);
+          μ, solver.hessian_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>(),
+                   step.p_z.template lpNorm<Eigen::Infinity>()),
+          α, α_max, α_reduction_factor, α_z);
     }
 
     ++iterations;

{sleipnirgroup_jormungandr-0.5.5.dev8 → sleipnirgroup_jormungandr-0.5.6.dev4}/include/sleipnir/optimization/solver/newton.hpp

@@ -258,11 +258,12 @@ ExitStatus newton(
     inner_iter_profiler.stop();
 
     if (options.diagnostics) {
-      print_iteration_diagnostics(iterations, IterationType::NORMAL,
-                                  inner_iter_profiler.current_duration(), E_0,
-                                  f, Scalar(0), Scalar(0), Scalar(0),
-                                  solver.hessian_regularization(), α, α_max,
-                                  α_reduction_factor, Scalar(1));
+      print_iteration_diagnostics(
+          iterations, IterationType::NORMAL,
+          inner_iter_profiler.current_duration(), E_0, f, Scalar(0), Scalar(0),
+          Scalar(0), solver.hessian_regularization(),
+          p_x.template lpNorm<Eigen::Infinity>(), Scalar(1), α, α_max,
+          α_reduction_factor, Scalar(1));
     }
 
     ++iterations;

{sleipnirgroup_jormungandr-0.5.5.dev8 → sleipnirgroup_jormungandr-0.5.6.dev4}/include/sleipnir/optimization/solver/sqp.hpp

@@ -394,8 +394,10 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
                   kkt_error<Scalar, KKTErrorType::INF_NORM_SCALED>(
                       g, A_e, trial_c_e, trial_y),
                   trial_f, trial_c_e.template lpNorm<1>(), Scalar(0), Scalar(0),
-                  solver.hessian_regularization(), α_soc, Scalar(1),
-                  α_reduction_factor, Scalar(1));
+                  solver.hessian_regularization(),
+                  soc_step.p_x.template lpNorm<Eigen::Infinity>(),
+                  soc_step.p_y.template lpNorm<Eigen::Infinity>(), α_soc,
+                  Scalar(1), α_reduction_factor, Scalar(1));
             }
           }};
 
@@ -557,8 +559,10 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
       print_iteration_diagnostics(iterations, IterationType::NORMAL,
                                   inner_iter_profiler.current_duration(), E_0,
                                   f, c_e.template lpNorm<1>(), Scalar(0),
-                                  Scalar(0), solver.hessian_regularization(), α,
-                                  α_max, α_reduction_factor, α);
+                                  Scalar(0), solver.hessian_regularization(),
+                                  step.p_x.template lpNorm<Eigen::Infinity>(),
+                                  step.p_y.template lpNorm<Eigen::Infinity>(),
+                                  α, α_max, α_reduction_factor, α);
     }
 
     ++iterations;

{sleipnirgroup_jormungandr-0.5.5.dev8 → sleipnirgroup_jormungandr-0.5.6.dev4}/include/sleipnir/optimization/solver/util/regularized_ldlt.hpp

@@ -56,6 +56,9 @@ class RegularizedLDLT {
 
   /// Computes the regularized LDLT factorization of a matrix.
   ///
+  /// The matrix's symbolic decomposition is reused in subsequent calls, so
+  /// subsequent calls must be given a matrix with the same sparsity pattern.
+  ///
   /// @param lhs Left-hand side of the system.
   /// @return The factorization.
   RegularizedLDLT& compute(const SparseMatrix& lhs) {
@@ -65,8 +68,12 @@ class RegularizedLDLT {
     // We consider less than 25% to be sparse.
     m_is_sparse = lhs.nonZeros() < 0.25 * lhs.size();
 
-    m_info = m_is_sparse ? compute_sparse(lhs).info()
-                         : m_dense_solver.compute(lhs).info();
+    // Regularization with zeros ensures the pattern analysis in
+    // compute_sparse() is reused by all factorizations
+    m_info =
+        m_is_sparse
+            ? compute_sparse(lhs + regularization(Scalar(0), Scalar(0))).info()
+            : m_dense_solver.compute(lhs).info();
 
     if (m_info == Eigen::Success) {
       auto D =

{sleipnirgroup_jormungandr-0.5.5.dev8 → sleipnirgroup_jormungandr-0.5.6.dev4}/include/sleipnir/util/print_diagnostics.hpp

@@ -182,6 +182,8 @@ inline void print_bound_constraint_global_infeasibility_error(
 /// @param complementarity The complementarity.
 /// @param μ The barrier parameter.
 /// @param δ The Hessian 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.
 /// @param primal_α_max The max primal step size.
 /// @param α_reduction_factor Factor by which primal_α is reduced during
@@ -192,33 +194,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 primal_α,
-                                 Scalar primal_α_max, Scalar α_reduction_factor,
-                                 Scalar dual_α) {
+                                 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::print("┏");
+      slp::println("┏{:━^116}┓", "");
     } else {
-      slp::print("┢");
-    }
-    slp::print(
-        "{:━^4}┯{:━^4}┯{:━^9}┯{:━^12}┯{:━^13}┯{:━^12}┯{:━^12}┯{:━^8}┯{:━^5}┯"
-        "{:━^8}┯{:━^8}┯{:━^2}",
-        "", "", "", "", "", "", "", "", "", "", "", "");
-    if (iterations == 0) {
-      slp::println("┓");
-    } else {
-      slp::println("┪");
+      slp::println("┢{:━^116}┪", "");
     }
     slp::println(
-        "┃{:^4}│{:^4}│{:^9}│{:^12}│{:^13}│{:^12}│{:^12}│{:^8}│{:^5}│{:^8}│{:^8}"
-        "│{:^2}┃",
-        "iter", "type", "time (ms)", "error", "cost", "infeas.", "complement.",
-        "μ", "reg", "primal α", "dual α", "↩");
-    slp::println(
-        "┡{:━^4}┷{:━^4}┷{:━^9}┷{:━^12}┷{:━^13}┷{:━^12}┷{:━^12}┷{:━^8}┷{:━^5}┷"
-        "{:━^8}┷{:━^8}┷{:━^2}┩",
-        "", "", "", "", "", "", "", "", "", "", "", "");
+        "┃{:^4} {:^4} {:^9} {:^10} {:^11} {:^10} {:^8} {:^8} {:^5} {:^8} {:^8} "
+        "{:^8} {:^8} {:^2}┃",
+        "iter", "type", "duration", "error", "cost", "infeas.", "complem.", "μ",
+        "δ", "|p_pr|", "|p_du|", "α_pr", "α_du", "↩");
+    slp::println("┡{:━^116}┩", "");
   }
 
   // For the number of backtracks, we want x such that:
@@ -237,10 +229,11 @@ void print_iteration_diagnostics(int iterations, IterationType type,
 
   constexpr std::array ITERATION_TYPES{"norm", "✓SOC", "XSOC", "rest"};
   slp::println(
-      "│{:4} {:4} {:9.3f} {:12e} {:13e} {:12e} {:12e} {:.2e} {:<5} {:.2e} "
-      "{:.2e} {:2d}│",
+      "│{:4} {:4} {:9.3f} {:.4e} {:11.4e} {:.4e} {:.2e} {:.2e} {:<5} {:.2e} "
+      "{:.2e} {:.2e} {:.2e} {:2d}│",
       iterations, ITERATION_TYPES[std::to_underlying(type)], to_ms(time), error,
-      cost, infeasibility, complementarity, μ, power_of_10(δ), primal_α, dual_α,
+      cost, infeasibility, complementarity, μ, power_of_10(δ),
+      full_primal_step_inf_norm, full_dual_step_inf_norm, primal_α, dual_α,
       backtracks);
 }
 #else
@@ -250,7 +243,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("└{:─^108}┘", "");
+  slp::println("└{:─^116}┘", "");
 }
 #else
 #define print_bottom_iteration_diagnostics(...)
@@ -296,10 +289,10 @@ inline void print_solver_diagnostics(
     const gch::small_vector<SolveProfiler>& solve_profilers) {
   auto solve_duration = to_ms(solve_profilers[0].total_duration());
 
-  slp::println("┏{:━^21}┯{:━^18}┯{:━^10}┯{:━^9}┯{:━^4}┓", "", "", "", "", "");
-  slp::println("┃{:^21}│{:^18}│{:^10}│{:^9}│{:^4}┃", "solver trace", "percent",
-               "total (ms)", "each (ms)", "runs");
-  slp::println("┡{:━^21}┷{:━^18}┷{:━^10}┷{:━^9}┷{:━^4}┩", "", "", "", "", "");
+  slp::println("┏{:━^66}┓", "");
+  slp::println("┃{:^21} {:^18} {:^10} {:^9} {:^4}┃", "time trace", "percentage",
+               "total", "each", "runs");
+  slp::println("┡{:━^66}┩", "");
 
   for (auto& profiler : solve_profilers) {
     double norm = solve_duration == 0.0
@@ -325,23 +318,26 @@ inline void print_setup_diagnostics(
     const gch::small_vector<SetupProfiler>& setup_profilers) {
   auto setup_duration = to_ms(setup_profilers[0].duration());
 
+  // Print link to diagnostic output description
+  slp::println(
+      "See https://sleipnirgroup.github.io/Sleipnir/md_usage.html#output for "
+      "diagnostic output description.\n");
+
   // Print heading
-  slp::println("┏{:━^21}┯{:━^18}┯{:━^10}┯{:━^9}┯{:━^4}┓", "", "", "", "", "");
-  slp::println("┃{:^21}│{:^18}│{:^10}│{:^9}│{:^4}┃", "setup trace", "percent",
-               "total (ms)", "each (ms)", "runs");
-  slp::println("┡{:━^21}┷{:━^18}┷{:━^10}┷{:━^9}┷{:━^4}┩", "", "", "", "", "");
+  slp::println("┏{:━^50}┓", "");
+  slp::println("┃{:^21} {:^18} {:^9}┃", "time trace", "percentage", "duration");
+  slp::println("┡{:━^50}┩", "");
 
   // Print setup profilers
   for (auto& profiler : setup_profilers) {
     double norm = setup_duration == 0.0
                       ? (&profiler == &setup_profilers[0] ? 1.0 : 0.0)
                       : to_ms(profiler.duration()) / setup_duration;
-    slp::println("│{:<21} {:>6.2f}%▕{}▏ {:>10.3f} {:>9.3f} {:>4}│",
-                 profiler.name(), norm * 100.0, histogram<9>(norm),
-                 to_ms(profiler.duration()), to_ms(profiler.duration()), "1");
+    slp::println("│{:<21} {:>6.2f}%▕{}▏ {:>9.3f}│", profiler.name(),
+                 norm * 100.0, histogram<9>(norm), to_ms(profiler.duration()));
   }
 
-  slp::println("└{:─^66}┘", "");
+  slp::println("└{:─^50}┘", "");
 }
 #else
 #define print_setup_diagnostics(...)

{sleipnirgroup_jormungandr-0.5.5.dev8 → sleipnirgroup_jormungandr-0.5.6.dev4}/python/cpp/docstrings.hpp

@@ -2152,7 +2152,7 @@ Returns:
     The contents of the variable matrix.)doc";
 
 static const char *__doc_slp_VariableMatrix_zero =
-R"doc(Returns a variable matrix filled with zeroes.
+R"doc(Returns a variable matrix filled with zeros.
 
 Parameter ``rows``:
     The number of matrix rows.
@@ -2161,7 +2161,7 @@ Parameter ``cols``:
     The number of matrix columns.
 
 Returns:
-    A variable matrix filled with zeroes.)doc";
+    A variable matrix filled with zeros.)doc";
 
 static const char *__doc_slp_Variable_Variable = R"doc(Constructs a linear Variable with a value of zero.)doc";
 

{sleipnirgroup_jormungandr-0.5.5.dev8 → sleipnirgroup_jormungandr-0.5.6.dev4}/python/src/sleipnir/__init__.py

@@ -2,4 +2,4 @@
 
 from ._sleipnir import *
 
-__version__ = "0.5.5.dev8"
+__version__ = "0.5.6.dev4"