sleipnirgroup-jormungandr 0.6.6.dev18__tar.gz → 0.6.6.dev20__tar.gz

{sleipnirgroup_jormungandr-0.6.6.dev18 → sleipnirgroup_jormungandr-0.6.6.dev20}/PKG-INFO

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

{sleipnirgroup_jormungandr-0.6.6.dev18 → sleipnirgroup_jormungandr-0.6.6.dev20}/include/sleipnir/optimization/solver/interior_point.hpp

@@ -21,7 +21,6 @@
 #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"
-#include "sleipnir/optimization/solver/util/is_locally_infeasible.hpp"
 #include "sleipnir/optimization/solver/util/kkt_error.hpp"
 #include "sleipnir/optimization/solver/util/regularized_ldlt.hpp"
 #include "sleipnir/util/assert.hpp"
@@ -156,7 +155,6 @@ ExitStatus interior_point(
   solve_profilers.emplace_back("solver");
   solve_profilers.emplace_back("↳ setup");
   solve_profilers.emplace_back("↳ iteration");
-  solve_profilers.emplace_back("  ↳ feasibility check");
   solve_profilers.emplace_back("  ↳ callbacks");
   solve_profilers.emplace_back("  ↳ KKT matrix build");
   solve_profilers.emplace_back("  ↳ KKT matrix decomp");
@@ -176,25 +174,24 @@ ExitStatus interior_point(
   auto& solver_prof = solve_profilers[0];
   auto& setup_prof = solve_profilers[1];
   auto& inner_iter_prof = solve_profilers[2];
-  auto& feasibility_check_prof = solve_profilers[3];
-  auto& iter_callbacks_prof = solve_profilers[4];
-  auto& kkt_matrix_build_prof = solve_profilers[5];
-  auto& kkt_matrix_decomp_prof = solve_profilers[6];
-  auto& kkt_system_solve_prof = solve_profilers[7];
-  auto& line_search_prof = solve_profilers[8];
-  auto& soc_prof = solve_profilers[9];
-  auto& feasibility_restoration_prof = solve_profilers[10];
+  auto& iter_callbacks_prof = solve_profilers[3];
+  auto& kkt_matrix_build_prof = solve_profilers[4];
+  auto& kkt_matrix_decomp_prof = solve_profilers[5];
+  auto& kkt_system_solve_prof = solve_profilers[6];
+  auto& line_search_prof = solve_profilers[7];
+  auto& soc_prof = solve_profilers[8];
+  auto& feasibility_restoration_prof = solve_profilers[9];
 
   // Set up profiled matrix callbacks
 #ifndef SLEIPNIR_DISABLE_DIAGNOSTICS
-  auto& f_prof = solve_profilers[11];
-  auto& g_prof = solve_profilers[12];
-  auto& H_prof = solve_profilers[13];
-  auto& H_c_prof = solve_profilers[14];
-  auto& c_e_prof = solve_profilers[15];
-  auto& A_e_prof = solve_profilers[16];
-  auto& c_i_prof = solve_profilers[17];
-  auto& A_i_prof = solve_profilers[18];
+  auto& f_prof = solve_profilers[10];
+  auto& g_prof = solve_profilers[11];
+  auto& H_prof = solve_profilers[12];
+  auto& H_c_prof = solve_profilers[13];
+  auto& c_e_prof = solve_profilers[14];
+  auto& A_e_prof = solve_profilers[15];
+  auto& c_i_prof = solve_profilers[16];
+  auto& A_i_prof = solve_profilers[17];
 
   InteriorPointMatrixCallbacks<Scalar> matrices{
       matrix_callbacks.num_decision_variables,
@@ -381,25 +378,6 @@ ExitStatus interior_point(
 
   while (E_0 > Scalar(options.tolerance)) {
     ScopedProfiler inner_iter_profiler{inner_iter_prof};
-    ScopedProfiler feasibility_check_profiler{feasibility_check_prof};
-
-    // Check for local equality constraint infeasibility
-    if (is_equality_locally_infeasible(A_e, c_e)) {
-      if (options.diagnostics) {
-        print_c_e_local_infeasibility_error(c_e, Scalar(options.tolerance));
-      }
-
-      return ExitStatus::LOCALLY_INFEASIBLE;
-    }
-
-    // Check for local inequality constraint infeasibility
-    if (is_inequality_locally_infeasible(A_i, c_i)) {
-      if (options.diagnostics) {
-        print_c_i_local_infeasibility_error(c_i, Scalar(options.tolerance));
-      }
-
-      return ExitStatus::LOCALLY_INFEASIBLE;
-    }
 
     // Check for diverging iterates
     if (x.template lpNorm<Eigen::Infinity>() > Scalar(1e10) || !x.allFinite() ||
@@ -407,7 +385,6 @@ ExitStatus interior_point(
       return ExitStatus::DIVERGING_ITERATES;
     }
 
-    feasibility_check_profiler.stop();
     ScopedProfiler iter_callbacks_profiler{iter_callbacks_prof};
 
     // Call iteration callbacks

{sleipnirgroup_jormungandr-0.6.6.dev18 → sleipnirgroup_jormungandr-0.6.6.dev20}/include/sleipnir/optimization/solver/newton.hpp

@@ -65,7 +65,6 @@ ExitStatus newton(
   solve_profilers.emplace_back("solver");
   solve_profilers.emplace_back("↳ setup");
   solve_profilers.emplace_back("↳ iteration");
-  solve_profilers.emplace_back("  ↳ feasibility check");
   solve_profilers.emplace_back("  ↳ callbacks");
   solve_profilers.emplace_back("  ↳ KKT matrix decomp");
   solve_profilers.emplace_back("  ↳ KKT system solve");
@@ -77,17 +76,16 @@ ExitStatus newton(
   auto& solver_prof = solve_profilers[0];
   auto& setup_prof = solve_profilers[1];
   auto& inner_iter_prof = solve_profilers[2];
-  auto& feasibility_check_prof = solve_profilers[3];
-  auto& iter_callbacks_prof = solve_profilers[4];
-  auto& kkt_matrix_decomp_prof = solve_profilers[5];
-  auto& kkt_system_solve_prof = solve_profilers[6];
-  auto& line_search_prof = solve_profilers[7];
+  auto& iter_callbacks_prof = solve_profilers[3];
+  auto& kkt_matrix_decomp_prof = solve_profilers[4];
+  auto& kkt_system_solve_prof = solve_profilers[5];
+  auto& line_search_prof = solve_profilers[6];
 
   // Set up profiled matrix callbacks
 #ifndef SLEIPNIR_DISABLE_DIAGNOSTICS
-  auto& f_prof = solve_profilers[8];
-  auto& g_prof = solve_profilers[9];
-  auto& H_prof = solve_profilers[10];
+  auto& f_prof = solve_profilers[7];
+  auto& g_prof = solve_profilers[8];
+  auto& H_prof = solve_profilers[9];
 
   NewtonMatrixCallbacks<Scalar> matrices{
       matrix_callbacks.num_decision_variables,
@@ -160,14 +158,12 @@ ExitStatus newton(
 
   while (E_0 > Scalar(options.tolerance)) {
     ScopedProfiler inner_iter_profiler{inner_iter_prof};
-    ScopedProfiler feasibility_check_profiler{feasibility_check_prof};
 
     // Check for diverging iterates
     if (x.template lpNorm<Eigen::Infinity>() > Scalar(1e10) || !x.allFinite()) {
       return ExitStatus::DIVERGING_ITERATES;
     }
 
-    feasibility_check_profiler.stop();
     ScopedProfiler iter_callbacks_profiler{iter_callbacks_prof};
 
     // Call iteration callbacks

{sleipnirgroup_jormungandr-0.6.6.dev18 → sleipnirgroup_jormungandr-0.6.6.dev20}/include/sleipnir/optimization/solver/sqp.hpp

@@ -19,7 +19,6 @@
 #include "sleipnir/optimization/solver/util/append_as_triplets.hpp"
 #include "sleipnir/optimization/solver/util/feasibility_restoration.hpp"
 #include "sleipnir/optimization/solver/util/filter.hpp"
-#include "sleipnir/optimization/solver/util/is_locally_infeasible.hpp"
 #include "sleipnir/optimization/solver/util/kkt_error.hpp"
 #include "sleipnir/optimization/solver/util/regularized_ldlt.hpp"
 #include "sleipnir/util/assert.hpp"
@@ -113,7 +112,6 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
   solve_profilers.emplace_back("solver");
   solve_profilers.emplace_back("↳ setup");
   solve_profilers.emplace_back("↳ iteration");
-  solve_profilers.emplace_back("  ↳ feasibility check");
   solve_profilers.emplace_back("  ↳ callbacks");
   solve_profilers.emplace_back("  ↳ KKT matrix build");
   solve_profilers.emplace_back("  ↳ KKT matrix decomp");
@@ -131,23 +129,22 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
   auto& solver_prof = solve_profilers[0];
   auto& setup_prof = solve_profilers[1];
   auto& inner_iter_prof = solve_profilers[2];
-  auto& feasibility_check_prof = solve_profilers[3];
-  auto& iter_callbacks_prof = solve_profilers[4];
-  auto& kkt_matrix_build_prof = solve_profilers[5];
-  auto& kkt_matrix_decomp_prof = solve_profilers[6];
-  auto& kkt_system_solve_prof = solve_profilers[7];
-  auto& line_search_prof = solve_profilers[8];
-  auto& soc_prof = solve_profilers[9];
-  auto& feasibility_restoration_prof = solve_profilers[10];
+  auto& iter_callbacks_prof = solve_profilers[3];
+  auto& kkt_matrix_build_prof = solve_profilers[4];
+  auto& kkt_matrix_decomp_prof = solve_profilers[5];
+  auto& kkt_system_solve_prof = solve_profilers[6];
+  auto& line_search_prof = solve_profilers[7];
+  auto& soc_prof = solve_profilers[8];
+  auto& feasibility_restoration_prof = solve_profilers[9];
 
   // Set up profiled matrix callbacks
 #ifndef SLEIPNIR_DISABLE_DIAGNOSTICS
-  auto& f_prof = solve_profilers[11];
-  auto& g_prof = solve_profilers[12];
-  auto& H_prof = solve_profilers[13];
-  auto& H_c_prof = solve_profilers[14];
-  auto& c_e_prof = solve_profilers[15];
-  auto& A_e_prof = solve_profilers[16];
+  auto& f_prof = solve_profilers[10];
+  auto& g_prof = solve_profilers[11];
+  auto& H_prof = solve_profilers[12];
+  auto& H_c_prof = solve_profilers[13];
+  auto& c_e_prof = solve_profilers[14];
+  auto& A_e_prof = solve_profilers[15];
 
   SQPMatrixCallbacks<Scalar> matrices{
       matrix_callbacks.num_decision_variables,
@@ -258,23 +255,12 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
 
   while (E_0 > Scalar(options.tolerance)) {
     ScopedProfiler inner_iter_profiler{inner_iter_prof};
-    ScopedProfiler feasibility_check_profiler{feasibility_check_prof};
-
-    // Check for local equality constraint infeasibility
-    if (is_equality_locally_infeasible(A_e, c_e)) {
-      if (options.diagnostics) {
-        print_c_e_local_infeasibility_error(c_e, Scalar(options.tolerance));
-      }
-
-      return ExitStatus::LOCALLY_INFEASIBLE;
-    }
 
     // Check for diverging iterates
     if (x.template lpNorm<Eigen::Infinity>() > Scalar(1e10) || !x.allFinite()) {
       return ExitStatus::DIVERGING_ITERATES;
     }
 
-    feasibility_check_profiler.stop();
     ScopedProfiler iter_callbacks_profiler{iter_callbacks_prof};
 
     // Call iteration callbacks

{sleipnirgroup_jormungandr-0.6.6.dev18 → sleipnirgroup_jormungandr-0.6.6.dev20}/include/sleipnir/optimization/solver/util/bounds.hpp

@@ -215,7 +215,7 @@ void project_onto_bounds(
     // We assume that bound infeasibility is handled elsewhere.
     slp_assert(lower <= upper);
 
-    // See B.2 in [5] and section 3.6 in [2]
+    // See B.2 in [4] and section 3.6 in [2]
     if (isfinite(lower) && isfinite(upper)) {
       auto p_L = std::min(κ_1 * std::max(Scalar(1), abs(lower)),
                           κ_2 * (upper - lower));

{sleipnirgroup_jormungandr-0.6.6.dev18 → sleipnirgroup_jormungandr-0.6.6.dev20}/include/sleipnir/optimization/solver/util/feasibility_restoration.hpp

@@ -21,6 +21,7 @@
 #include "sleipnir/optimization/solver/util/append_as_triplets.hpp"
 #include "sleipnir/optimization/solver/util/lagrange_multiplier_estimate.hpp"
 #include "sleipnir/optimization/solver/util/problem_scaling.hpp"
+#include "sleipnir/util/print_diagnostics.hpp"
 
 namespace slp {
 
@@ -318,7 +319,26 @@ ExitStatus feasibility_restoration(
 
     return ExitStatus::SUCCESS;
   } else if (status == ExitStatus::SUCCESS) {
-    return ExitStatus::LOCALLY_INFEASIBLE;
+    // Feasibility restoration converged to a minimizer of the constraint
+    // violation. If the constraint violation is still above the tolerance,
+    // that minimizer is a certificate of local infeasibility. Declaring local
+    // infeasibility anywhere else risks false positives (e.g., a
+    // point-in-time test can reject iterates the solver would otherwise
+    // escape). See section 3.3, p. 14 of [2].
+    DenseVector c_e = matrices.c_e(x);
+    if (matrices.scaling.c_e.size() > 0) {
+      c_e = matrices.scaling.c_e.cwiseInverse().cwiseProduct(c_e);
+    }
+
+    if (c_e.template lpNorm<Eigen::Infinity>() > Scalar(options.tolerance)) {
+      if (options.diagnostics) {
+        print_c_e_local_infeasibility_error(c_e, Scalar(options.tolerance));
+      }
+
+      return ExitStatus::LOCALLY_INFEASIBLE;
+    }
+
+    return ExitStatus::FEASIBILITY_RESTORATION_FAILED;
   } else {
     return ExitStatus::FEASIBILITY_RESTORATION_FAILED;
   }
@@ -621,7 +641,45 @@ ExitStatus feasibility_restoration(
 
     return ExitStatus::SUCCESS;
   } else if (status == ExitStatus::SUCCESS) {
-    return ExitStatus::LOCALLY_INFEASIBLE;
+    // Feasibility restoration converged to a minimizer of the constraint
+    // violation. If the constraint violation is still above the tolerance,
+    // that minimizer is a certificate of local infeasibility. Declaring local
+    // infeasibility anywhere else risks false positives (e.g., a
+    // point-in-time test can reject iterates the solver would otherwise
+    // escape). See section 3.3, p. 14 of [2].
+    DenseVector c_e = matrices.c_e(x);
+    if (matrices.scaling.c_e.size() > 0) {
+      c_e = matrices.scaling.c_e.cwiseInverse().cwiseProduct(c_e);
+    }
+
+    DenseVector c_i = matrices.c_i(x);
+    if (matrices.scaling.c_i.size() > 0) {
+      c_i = matrices.scaling.c_i.cwiseInverse().cwiseProduct(c_i);
+    }
+
+    // Inequality constraints cᵢ(x) ≥ 0 are only violated where they're
+    // negative
+    const DenseVector c_i_violation = (-c_i).cwiseMax(Scalar(0));
+
+    const bool c_e_violated =
+        c_e.template lpNorm<Eigen::Infinity>() > Scalar(options.tolerance);
+    const bool c_i_violated = c_i_violation.template lpNorm<Eigen::Infinity>() >
+                              Scalar(options.tolerance);
+
+    if (c_e_violated || c_i_violated) {
+      if (options.diagnostics) {
+        if (c_e_violated) {
+          print_c_e_local_infeasibility_error(c_e, Scalar(options.tolerance));
+        }
+        if (c_i_violated) {
+          print_c_i_local_infeasibility_error(c_i, Scalar(options.tolerance));
+        }
+      }
+
+      return ExitStatus::LOCALLY_INFEASIBLE;
+    }
+
+    return ExitStatus::FEASIBILITY_RESTORATION_FAILED;
   } else {
     return ExitStatus::FEASIBILITY_RESTORATION_FAILED;
   }

{sleipnirgroup_jormungandr-0.6.6.dev18 → sleipnirgroup_jormungandr-0.6.6.dev20}/include/sleipnir/optimization/solver/util/filter.hpp

@@ -131,7 +131,7 @@ class Filter {
 
     // Sufficient decrease condition
     //
-    // See equation (2.13) of [4].
+    // See equation (2.13) of [3].
     Scalar ϕ = pow(α, Scalar(1.5));
     bool sufficient_decrease =
         trial_entry.cost <=

{sleipnirgroup_jormungandr-0.6.6.dev18 → sleipnirgroup_jormungandr-0.6.6.dev20}/python/src/sleipnir/__init__.py

@@ -2,4 +2,4 @@
 
 from ._sleipnir import *
 
-__version__ = "0.6.6.dev18"
+__version__ = "0.6.6.dev20"

{sleipnirgroup_jormungandr-0.6.6.dev18 → sleipnirgroup_jormungandr-0.6.6.dev20}/python/test/optimization/solver/exit_status_test.py

@@ -1,5 +1,6 @@
 """These tests ensure coverage of the off-nominal exit statuses"""
 
+import pytest
 from sleipnir.autodiff import ExpressionType, sqrt
 from sleipnir.optimization import ExitStatus, Problem
 
@@ -72,6 +73,38 @@ def test_locally_infeasible_inequality_constraints():
     assert problem.solve(diagnostics=True) == ExitStatus.LOCALLY_INFEASIBLE
 
 
+def test_small_equality_constraint_scaling_is_feasible():
+    problem = Problem()
+
+    x = problem.decision_variable()
+    x.set_value(5005)
+
+    problem.subject_to(1e-5 * (x - 5) == 0)
+
+    assert problem.cost_function_type() == ExpressionType.NONE
+    assert problem.equality_constraint_type() == ExpressionType.LINEAR
+    assert problem.inequality_constraint_type() == ExpressionType.NONE
+
+    assert problem.solve(diagnostics=True) == ExitStatus.SUCCESS
+    assert x.value() == pytest.approx(5, abs=1e-3)
+
+
+def test_small_inequality_constraint_scaling_is_feasible():
+    problem = Problem()
+
+    x = problem.decision_variable()
+    x.set_value(5005)
+
+    problem.subject_to(1e-5 * (5 - x) >= 0)
+
+    assert problem.cost_function_type() == ExpressionType.NONE
+    assert problem.equality_constraint_type() == ExpressionType.NONE
+    assert problem.inequality_constraint_type() == ExpressionType.LINEAR
+
+    assert problem.solve(diagnostics=True) == ExitStatus.SUCCESS
+    assert x.value() <= 5 + 1e-3
+
+
 def test_nonfinite_cost():
     problem = Problem()
     x = problem.decision_variable()

sleipnirgroup_jormungandr-0.6.6.dev18/include/sleipnir/optimization/solver/util/is_locally_infeasible.hpp

@@ -1,62 +0,0 @@
-// Copyright (c) Sleipnir contributors
-
-#pragma once
-
-#include <Eigen/Core>
-#include <Eigen/SparseCore>
-
-// See docs/algorithms.md#Works_cited for citation definitions
-
-namespace slp {
-
-/// Returns true if the problem's equality constraints are locally infeasible.
-///
-/// @tparam Scalar Scalar type.
-/// @param A_e Equality constraint Jacobian Aₑ(x).
-/// @param c_e Equality constraints cₑ(x).
-template <typename Scalar>
-bool is_equality_locally_infeasible(
-    const Eigen::SparseMatrix<Scalar>& A_e,
-    const Eigen::Vector<Scalar, Eigen::Dynamic>& c_e) {
-  // The equality constraints are locally infeasible if
-  //
-  //   Aₑᵀcₑ → 0
-  //   ‖cₑ‖ > ε
-  //
-  // See "Infeasibility detection" in section 6 of [3].
-  return A_e.rows() > 0 && (A_e.transpose() * c_e).norm() < Scalar(1e-6) &&
-         c_e.norm() > Scalar(1e-2);
-}
-
-/// Returns true if the problem's inequality constraints are locally infeasible.
-///
-/// @tparam Scalar Scalar type.
-/// @param A_i Inequality constraint Jacobian Aᵢ(x).
-/// @param c_i Inequality constraints cᵢ(x).
-template <typename Scalar>
-bool is_inequality_locally_infeasible(
-    const Eigen::SparseMatrix<Scalar>& A_i,
-    const Eigen::Vector<Scalar, Eigen::Dynamic>& c_i) {
-  // The inequality constraints are locally infeasible if
-  //
-  //   Aᵢᵀcᵢ⁺ → 0
-  //   ‖cᵢ⁺‖ > ε
-  //
-  // where cᵢ⁺ = min(cᵢ, 0).
-  //
-  // See "Infeasibility detection" in section 6 of [3].
-  //
-  // cᵢ⁺ is used instead of cᵢ⁻ from the paper to follow the convention that
-  // feasible inequality constraints are ≥ 0.
-  if (A_i.rows() > 0) {
-    Eigen::Vector<Scalar, Eigen::Dynamic> c_i_plus = c_i.cwiseMin(Scalar(0));
-    if ((A_i.transpose() * c_i_plus).norm() < Scalar(1e-6) &&
-        c_i_plus.norm() > Scalar(1e-6)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-}  // namespace slp