sleipnirgroup-jormungandr 0.6.7.dev66__tar.gz → 0.6.7.dev68__tar.gz

{sleipnirgroup_jormungandr-0.6.7.dev66 → sleipnirgroup_jormungandr-0.6.7.dev68}/PKG-INFO

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

{sleipnirgroup_jormungandr-0.6.7.dev66 → sleipnirgroup_jormungandr-0.6.7.dev68}/include/sleipnir/optimization/solver/ipm.hpp

@@ -18,6 +18,7 @@
 #include "sleipnir/optimization/solver/options.hpp"
 #include "sleipnir/optimization/solver/util/all_finite.hpp"
 #include "sleipnir/optimization/solver/util/append_as_triplets.hpp"
+#include "sleipnir/optimization/solver/util/constraint_violation.hpp"
 #include "sleipnir/optimization/solver/util/feasibility_restoration.hpp"
 #include "sleipnir/optimization/solver/util/filter.hpp"
 #include "sleipnir/optimization/solver/util/fraction_to_the_boundary_rule.hpp"
@@ -144,6 +145,22 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
     DenseVector p_y;
     /// Inequality constraint dual step.
     DenseVector p_z;
+
+    /// Returns the infinity norm of the primal step.
+    ///
+    /// @return The infinity norm of the primal step.
+    Scalar primal_inf_norm() const {
+      return std::max(p_x.template lpNorm<Eigen::Infinity>(),
+                      p_s.template lpNorm<Eigen::Infinity>());
+    }
+
+    /// Returns the infinity norm of the dual step.
+    ///
+    /// @return The infinity norm of the dual step.
+    Scalar dual_inf_norm() const {
+      return std::max(p_y.template lpNorm<Eigen::Infinity>(),
+                      p_z.template lpNorm<Eigen::Infinity>());
+    }
   };
 
   using std::isfinite;
@@ -296,8 +313,7 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
   // Fraction-to-the-boundary rule scale factor τ
   Scalar τ = τ_min;
 
-  Filter<Scalar> filter{c_e.template lpNorm<1>() +
-                        (c_i - s).template lpNorm<1>()};
+  Filter<Scalar> filter{constraint_violation(c_e, c_i, s)};
 
   // This should be run when the error is below a desired threshold for the
   // current barrier parameter
@@ -379,9 +395,8 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
 
   // Print initial iterate diagnostics
   if (options.diagnostics) {
-    print_initial_iterate_diagnostics(
-        E_0, f, c_e.template lpNorm<1>() + (c_i - s).template lpNorm<1>(),
-        s.dot(z), μ);
+    print_initial_iterate_diagnostics(E_0, f, constraint_violation(c_e, c_i, s),
+                                      s.dot(z), μ);
   }
 
   while (E_0 > Scalar(options.tolerance)) {
@@ -533,11 +548,9 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
         break;
       }
 
-      Scalar prev_constraint_violation =
-          c_e.template lpNorm<1>() + (c_i - s).template lpNorm<1>();
+      Scalar prev_constraint_violation = constraint_violation(c_e, c_i, s);
       Scalar next_constraint_violation =
-          trial_c_e.template lpNorm<1>() +
-          (trial_c_i - trial_s).template lpNorm<1>();
+          constraint_violation(trial_c_e, trial_c_i, trial_s);
 
       // Second-order corrections
       //
@@ -570,16 +583,11 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
                   unscaled_kkt_error<Scalar, KKTErrorType::INF_NORM_SCALED>(
                       matrices.scaling, g, A_e, trial_c_e, A_i, trial_c_i,
                       trial_s, trial_y, trial_z, Scalar(0)),
-                  trial_f,
-                  trial_c_e.template lpNorm<1>() +
-                      (trial_c_i - trial_s).template lpNorm<1>(),
+                  trial_f, constraint_violation(trial_c_e, trial_c_i, trial_s),
                   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>(),
-                           soc_step.p_z.template lpNorm<Eigen::Infinity>()),
-                  α_soc, Scalar(1), α_reduction_factor, α_z_soc);
+                  soc_step.primal_inf_norm(), soc_step.dual_inf_norm(), α_soc,
+                  Scalar(1), α_reduction_factor, α_z_soc);
             }
           }};
 
@@ -633,8 +641,7 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
           // If constraint violation hasn't been sufficiently reduced, stop
           // making second-order corrections
           next_constraint_violation =
-              trial_c_e.template lpNorm<1>() +
-              (trial_c_i - trial_s).template lpNorm<1>();
+              constraint_violation(trial_c_e, trial_c_i, trial_s);
           if (next_constraint_violation > κ_soc * soc_constraint_violation) {
             break;
           }
@@ -835,14 +842,10 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
           in_feasibility_restoration ? IterationType::FEASIBILITY_RESTORATION
                                      : 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(),
-          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>(),
-                   step.p_z.template lpNorm<Eigen::Infinity>()),
-          α, α_max, α_reduction_factor, α_z);
+          constraint_violation(c_e, c_i, s), s.dot(z), μ,
+          solver.hessian_regularization(),
+          solver.constraint_jacobian_regularization(), step.primal_inf_norm(),
+          step.dual_inf_norm(), α, α_max, α_reduction_factor, α_z);
     }
 
     ++iterations;

{sleipnirgroup_jormungandr-0.6.7.dev66 → sleipnirgroup_jormungandr-0.6.7.dev68}/include/sleipnir/optimization/solver/sqp.hpp

@@ -17,6 +17,7 @@
 #include "sleipnir/optimization/solver/sqp_matrix_callbacks.hpp"
 #include "sleipnir/optimization/solver/util/all_finite.hpp"
 #include "sleipnir/optimization/solver/util/append_as_triplets.hpp"
+#include "sleipnir/optimization/solver/util/constraint_violation.hpp"
 #include "sleipnir/optimization/solver/util/feasibility_restoration.hpp"
 #include "sleipnir/optimization/solver/util/filter.hpp"
 #include "sleipnir/optimization/solver/util/kkt_error.hpp"
@@ -102,6 +103,20 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
     DenseVector p_x;
     /// Equality constraint dual step.
     DenseVector p_y;
+
+    /// Returns the infinity norm of the primal step.
+    ///
+    /// @return The infinity norm of the primal step.
+    Scalar primal_inf_norm() const {
+      return p_x.template lpNorm<Eigen::Infinity>();
+    }
+
+    /// Returns the infinity norm of the dual step.
+    ///
+    /// @return The infinity norm of the dual step.
+    Scalar dual_inf_norm() const {
+      return p_y.template lpNorm<Eigen::Infinity>();
+    }
   };
 
   using std::isfinite;
@@ -218,7 +233,7 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
 
   int iterations = 0;
 
-  Filter<Scalar> filter{c_e.template lpNorm<1>()};
+  Filter<Scalar> filter{constraint_violation(c_e)};
 
   // Kept outside the loop so its storage can be reused
   gch::small_vector<Eigen::Triplet<Scalar>> triplets;
@@ -257,7 +272,7 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
 
   // Print initial iterate diagnostics
   if (options.diagnostics) {
-    print_initial_iterate_diagnostics(E_0, f, c_e.template lpNorm<1>(),
+    print_initial_iterate_diagnostics(E_0, f, constraint_violation(c_e),
                                       Scalar(0), Scalar(0));
   }
 
@@ -363,8 +378,8 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
         break;
       }
 
-      Scalar prev_constraint_violation = c_e.template lpNorm<1>();
-      Scalar next_constraint_violation = trial_c_e.template lpNorm<1>();
+      Scalar prev_constraint_violation = constraint_violation(c_e);
+      Scalar next_constraint_violation = constraint_violation(trial_c_e);
 
       // Second-order corrections
       //
@@ -394,11 +409,10 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
                   soc_profiler.current_duration(),
                   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(),
+                  trial_f, constraint_violation(trial_c_e), 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,
+                  soc_step.primal_inf_norm(), soc_step.dual_inf_norm(), α_soc,
                   Scalar(1), α_reduction_factor, Scalar(1));
             }
           }};
@@ -435,7 +449,7 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
 
           // If constraint violation hasn't been sufficiently reduced, stop
           // making second-order corrections
-          next_constraint_violation = trial_c_e.template lpNorm<1>();
+          next_constraint_violation = constraint_violation(trial_c_e);
           if (next_constraint_violation > κ_soc * soc_constraint_violation) {
             break;
           }
@@ -576,12 +590,11 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
     if (options.diagnostics) {
       print_iteration_diagnostics(iterations, IterationType::NORMAL,
                                   inner_iter_profiler.current_duration(), E_0,
-                                  f, c_e.template lpNorm<1>(), Scalar(0),
+                                  f, constraint_violation(c_e), 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, α);
+                                  step.primal_inf_norm(), step.dual_inf_norm(),
+                                  α, α_max, α_reduction_factor, Scalar(1));
     }
 
     ++iterations;

sleipnirgroup_jormungandr-0.6.7.dev68/include/sleipnir/optimization/solver/util/constraint_violation.hpp

@@ -0,0 +1,34 @@
+// Copyright (c) Sleipnir contributors
+
+#pragma once
+
+#include <Eigen/Core>
+
+namespace slp {
+
+/// Returns the constraint violation for a Sequential Quadratic Programming
+/// iterate.
+///
+/// @tparam Scalar Scalar type.
+/// @param c_e The equality constraint values (nonzero means violation).
+/// @return The constraint violation.
+template <typename Scalar>
+Scalar constraint_violation(const Eigen::Vector<Scalar, Eigen::Dynamic>& c_e) {
+  return c_e.template lpNorm<1>();
+}
+
+/// Returns the constraint violation for an interior-point method iterate.
+///
+/// @tparam Scalar Scalar type.
+/// @param c_e The equality constraint values (nonzero means violation).
+/// @param c_i The inequality constraint values (negative means violation).
+/// @param s The inequality constraint slack variables.
+/// @return The constraint violation.
+template <typename Scalar>
+Scalar constraint_violation(const Eigen::Vector<Scalar, Eigen::Dynamic>& c_e,
+                            const Eigen::Vector<Scalar, Eigen::Dynamic>& c_i,
+                            const Eigen::Vector<Scalar, Eigen::Dynamic>& s) {
+  return c_e.template lpNorm<1>() + (c_i - s).template lpNorm<1>();
+}
+
+}  // namespace slp

{sleipnirgroup_jormungandr-0.6.7.dev66 → sleipnirgroup_jormungandr-0.6.7.dev68}/include/sleipnir/optimization/solver/util/filter.hpp

@@ -8,6 +8,8 @@
 #include <Eigen/Core>
 #include <gch/small_vector.hpp>
 
+#include "sleipnir/optimization/solver/util/constraint_violation.hpp"
+
 // See docs/algorithms.md#Works_cited for citation definitions.
 
 namespace slp {
@@ -41,7 +43,7 @@ struct FilterEntry {
   /// @param f The cost function value.
   /// @param c_e The equality constraint values (nonzero means violation).
   FilterEntry(Scalar f, const DenseVector& c_e)
-      : FilterEntry{f, c_e.template lpNorm<1>()} {}
+      : FilterEntry{f, slp::constraint_violation(c_e)} {}
 
   /// Constructs an interior-point method filter entry.
   ///
@@ -53,8 +55,7 @@ struct FilterEntry {
   FilterEntry(Scalar f, DenseVector& s, const DenseVector& c_e,
               const DenseVector& c_i, Scalar μ)
       : FilterEntry{f - μ * s.array().log().sum(),
-                    c_e.template lpNorm<1>() + (c_i - s).template lpNorm<1>()} {
-  }
+                    slp::constraint_violation(c_e, c_i, s)} {}
 
   /// Returns true if this filter entry is dominated by another.
   ///

{sleipnirgroup_jormungandr-0.6.7.dev66 → sleipnirgroup_jormungandr-0.6.7.dev68}/include/sleipnir/util/print_diagnostics.hpp

@@ -193,7 +193,7 @@ void print_initial_iterate_diagnostics(Scalar error, Scalar cost,
       "┃{:^4}   {:^9} {:^10} {:^11} {:^10} {:^8} {:^8} {:^5} {:^5} {:^8} {:^8} "
       "{:^8} {:^8} {:^2}┃",
       "iter", "duration", "error", "cost", "infeas.", "complem.", "μ", "δ", "γ",
-      "|p_pr|", "|p_du|", "α_pr", "α_du", "↩");
+      "|p_pr|", "|p_du|", "α", "α_z", "↩");
   slp::println("┡{:━^119}┩", "");
 
   slp::println(
@@ -220,28 +220,25 @@ void print_initial_iterate_diagnostics(Scalar error, Scalar cost,
 /// @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.
-/// @param primal_α_max The max primal step size.
-/// @param α_reduction_factor Factor by which primal_α is reduced during
-///     backtracking.
-/// @param dual_α The dual step size.
+/// @param α The step size for the decision variables, inequality constraint
+///     slack variables, and equality constraint dual variables.
+/// @param α_max The max step size for α.
+/// @param α_reduction_factor Factor by which α is reduced during backtracking.
+/// @param α_z The step size for the inequality constraint dual variables.
 template <typename Scalar, typename Rep, typename Period = std::ratio<1>>
-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 full_primal_step_inf_norm,
-                                 Scalar full_dual_step_inf_norm,
-                                 Scalar primal_α, Scalar primal_α_max,
-                                 Scalar α_reduction_factor, Scalar dual_α) {
+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 full_primal_step_inf_norm, Scalar full_dual_step_inf_norm, Scalar α,
+    Scalar α_max, Scalar α_reduction_factor, Scalar α_z) {
   if (iterations > 0 && iterations % 20 == 0) {
     slp::println("┢{:━^119}┪", "");
     slp::println(
         "┃{:^4}   {:^9} {:^10} {:^11} {:^10} {:^8} {:^8} {:^5} {:^5} {:^8} "
         "{:^8} {:^8} {:^8} {:^2}┃",
         "iter", "duration", "error", "cost", "infeas.", "complem.", "μ", "δ",
-        "γ", "|p_pr|", "|p_du|", "α_pr", "α_du", "↩");
+        "γ", "|p_pr|", "|p_du|", "α", "α_z", "↩");
     slp::println("┡{:━^119}┩", "");
   }
 
@@ -256,8 +253,7 @@ void print_iteration_diagnostics(int iterations, IterationType type,
   //   x ln(r) = ln(α/αᵐᵃˣ)
   //   x = ln(α/αᵐᵃˣ)/ln(r)
   using std::log;
-  int backtracks =
-      static_cast<int>(log(primal_α / primal_α_max) / log(α_reduction_factor));
+  int backtracks = static_cast<int>(log(α / α_max) / log(α_reduction_factor));
 
   constexpr std::array ITERATION_TYPES{" ", "s", "r"};
   slp::println(
@@ -265,8 +261,7 @@ void print_iteration_diagnostics(int iterations, IterationType type,
       "{:<5} {:8.2e} {:8.2e} {:8.2e} {:8.2e} {:2d}│",
       iterations, ITERATION_TYPES[std::to_underlying(type)], to_ms(time), error,
       cost, infeasibility, complementarity, μ, power_of_10(δ), power_of_10(γ),
-      full_primal_step_inf_norm, full_dual_step_inf_norm, primal_α, dual_α,
-      backtracks);
+      full_primal_step_inf_norm, full_dual_step_inf_norm, α, α_z, backtracks);
 }
 #else
 #define print_iteration_diagnostics(...)

{sleipnirgroup_jormungandr-0.6.7.dev66 → sleipnirgroup_jormungandr-0.6.7.dev68}/python/src/sleipnir/__init__.py

@@ -2,4 +2,4 @@
 
 from ._sleipnir import *
 
-__version__ = "0.6.7.dev66"
+__version__ = "0.6.7.dev68"