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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sleipnirgroup-jormungandr
-Version: 0.6.7.dev66
+Version: 0.6.7.dev67
 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.dev67}/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"
@@ -296,8 +297,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 +379,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 +532,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,9 +567,7 @@ 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>(),
@@ -633,8 +628,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,8 +829,8 @@ 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(),
+          constraint_violation(c_e, c_i, s), 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>()),

{sleipnirgroup_jormungandr-0.6.7.dev66 → sleipnirgroup_jormungandr-0.6.7.dev67}/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"
@@ -218,7 +219,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 +258,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 +364,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,8 +395,8 @@ 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,
@@ -435,7 +436,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,7 +577,7 @@ 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>(),

sleipnirgroup_jormungandr-0.6.7.dev67/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.dev67}/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.dev67}/python/src/sleipnir/__init__.py

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