sleipnirgroup-jormungandr 0.6.7.dev34__tar.gz → 0.6.7.dev36__tar.gz

{sleipnirgroup_jormungandr-0.6.7.dev34 → sleipnirgroup_jormungandr-0.6.7.dev36}/PKG-INFO

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

{sleipnirgroup_jormungandr-0.6.7.dev34 → sleipnirgroup_jormungandr-0.6.7.dev36}/include/sleipnir/optimization/solver/ipm.hpp

@@ -353,6 +353,8 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
 
   int full_step_rejected_counter = 0;
 
+  StallDetector<Scalar> stall_detector;
+
   // Error
   Scalar E_0 = unscaled_kkt_error<Scalar, KKTErrorType::INF_NORM_SCALED>(
       matrices.scaling, g, A_e, c_e, A_i, c_i, s, y, z, Scalar(0));
@@ -504,7 +506,7 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
       } else {
         trial_s = s + α * step.p_s;
       }
-      trial_y = y + α_z * step.p_y;
+      trial_y = y + α * step.p_y;
       trial_z = z + α_z * step.p_z;
 
       trial_f = matrices.f(trial_x);
@@ -608,7 +610,7 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
 
           trial_x = x + α_soc * soc_step.p_x;
           trial_s = s + α_soc * soc_step.p_s;
-          trial_y = y + α_z_soc * soc_step.p_y;
+          trial_y = y + α_soc * soc_step.p_y;
           trial_z = z + α_z_soc * soc_step.p_z;
 
           trial_f = matrices.f(trial_x);
@@ -677,7 +679,7 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
 
         trial_x = x + α_max * step.p_x;
         trial_s = s + α_max * step.p_s;
-        trial_y = y + α_z * step.p_y;
+        trial_y = y + α_max * step.p_y;
         trial_z = z + α_z * step.p_z;
 
         trial_f = matrices.f(trial_x);
@@ -702,6 +704,15 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
 
     line_search_profiler.stop();
 
+    // If solver stalled, invoke feasibility restoration
+    if (!call_feasibility_restoration && !in_feasibility_restoration) {
+      FilterEntry trial_entry{trial_f, trial_s, trial_c_e, trial_c_i, μ};
+      if (stall_detector.update(current_entry, trial_entry, α,
+                                filter.min_constraint_violation)) {
+        call_feasibility_restoration = true;
+      }
+    }
+
     if (call_feasibility_restoration) {
       ScopedProfiler feasibility_restoration_profiler{
           feasibility_restoration_prof};

{sleipnirgroup_jormungandr-0.6.7.dev34 → sleipnirgroup_jormungandr-0.6.7.dev36}/include/sleipnir/optimization/solver/sqp.hpp

@@ -236,6 +236,8 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
 
   int full_step_rejected_counter = 0;
 
+  StallDetector<Scalar> stall_detector;
+
   // Error
   Scalar E_0 = unscaled_kkt_error<Scalar, KKTErrorType::INF_NORM_SCALED>(
       matrices.scaling, g, A_e, c_e, y);
@@ -499,6 +501,15 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
 
     line_search_profiler.stop();
 
+    // If solver stalled, invoke feasibility restoration
+    if (!call_feasibility_restoration) {
+      FilterEntry trial_entry{trial_f, trial_c_e};
+      if (stall_detector.update(current_entry, trial_entry, α,
+                                filter.min_constraint_violation)) {
+        call_feasibility_restoration = true;
+      }
+    }
+
     if (call_feasibility_restoration) {
       ScopedProfiler feasibility_restoration_profiler{
           feasibility_restoration_prof};

{sleipnirgroup_jormungandr-0.6.7.dev34 → sleipnirgroup_jormungandr-0.6.7.dev36}/include/sleipnir/optimization/solver/util/filter.hpp

@@ -211,4 +211,47 @@ class Filter {
   }
 };
 
+/// Detects a solver stall.
+///
+/// @tparam Scalar Scalar type.
+template <typename Scalar>
+class StallDetector {
+ public:
+  /// Returns true if the solver stalled.
+  ///
+  /// @param current_entry The entry corresponding to the current iterate.
+  /// @param trial_entry The entry corresponding to the accepted trial iterate.
+  /// @param α The accepted step size.
+  /// @param min_constraint_violation The minimum constraint violation from the
+  ///     filter.
+  /// @return True if the solver stalled.
+  bool update(const FilterEntry<Scalar>& current_entry,
+              const FilterEntry<Scalar>& trial_entry, Scalar α,
+              Scalar min_constraint_violation) {
+    // If step is tiny, current iterate is infeasible, and accepted trial
+    // iterate made insufficient progress toward feasibility, increment stalled
+    // step counter
+    if (α < Scalar(1e-3) &&
+        current_entry.constraint_violation > min_constraint_violation &&
+        trial_entry.constraint_violation >
+            Scalar(0.99) * current_entry.constraint_violation) {
+      ++m_stalled_step_counter;
+
+      // If there were too many consecutive tiny steps, report a stall
+      if (++m_stalled_step_counter >= 5) {
+        m_stalled_step_counter = 0;
+        return true;
+      }
+    } else {
+      // A break in stalled steps resets the counter
+      m_stalled_step_counter = 0;
+    }
+
+    return false;
+  }
+
+ private:
+  int m_stalled_step_counter = 0;
+};
+
 }  // namespace slp

{sleipnirgroup_jormungandr-0.6.7.dev34 → sleipnirgroup_jormungandr-0.6.7.dev36}/python/src/sleipnir/__init__.py

@@ -2,4 +2,4 @@
 
 from ._sleipnir import *
 
-__version__ = "0.6.7.dev34"
+__version__ = "0.6.7.dev36"

{sleipnirgroup_jormungandr-0.6.7.dev34 → sleipnirgroup_jormungandr-0.6.7.dev36}/python/test/optimization/cart_pole_problem_test.py

@@ -15,9 +15,11 @@ def lerp(a, b, t):
     return a + t * (b - a)
 
 
-def test_cart_pole_problem():
+# dt = 0.25 s is sensitive to small solver changes, so a failure here may just
+# mean the iterates found a different basin rather than a regression.
+@pytest.mark.parametrize("dt", [0.05, 0.125, 0.25])
+def test_cart_pole_problem(dt):
     TOTAL_TIME = 5.0  # s
-    dt = 0.05  # s
     N = int(TOTAL_TIME / dt)
 
     u_max = 20.0  # N

{sleipnirgroup_jormungandr-0.6.7.dev34 → sleipnirgroup_jormungandr-0.6.7.dev36}/python/test/optimization/flywheel_ocp_test.py

@@ -96,7 +96,7 @@ def flywheel_test(
                 # steady-states.
                 assert problem.U().value(0, k) == pytest.approx(u, abs=2.0)
             else:
-                assert problem.U().value(0, k) == pytest.approx(u, abs=1e-4)
+                assert problem.U().value(0, k) == pytest.approx(u, abs=2e-4)
 
         # Project state forward
         x = A_discrete * x + B_discrete * u

{sleipnirgroup_jormungandr-0.6.7.dev34 → sleipnirgroup_jormungandr-0.6.7.dev36}/python/test/optimization/flywheel_problem_test.py

@@ -83,7 +83,7 @@ def test_flywheel_problem():
             assert U.value(0, k) >= u_ss
             assert U.value(0, k) <= 12.0
         else:
-            assert U.value(0, k) == pytest.approx(u, abs=1e-4)
+            assert U.value(0, k) == pytest.approx(u, abs=2e-4)
 
         # Project state forward
         x = A * x + B * u

{sleipnirgroup_jormungandr-0.6.7.dev34 → sleipnirgroup_jormungandr-0.6.7.dev36}/python/test/optimization/nonlinear_problem_test.py

@@ -160,3 +160,35 @@ def test_wachter_and_biegler_line_search_failure():
         assert x.value() == pytest.approx(-1.0, abs=1e-6)
         assert s1.value() == pytest.approx(0.0, abs=1e-6)
         assert s2.value() == pytest.approx(0.0, abs=3e-5)
+
+
+def test_hock_schittkowski_13():
+    # Problem 13 of [1] (see
+    # https://vanderbei.princeton.edu/ampl/nlmodels/cute/hs013.mod) has
+    # constraint gradients that are linearly dependent at the solution.
+    #
+    # [1] Hock, W. and Schittkowski, K. "Test Examples for Nonlinear Programming
+    #     Codes", Springer, 1981.
+
+    problem = Problem()
+
+    x, y = problem.decision_variable(2)
+    x.set_value(-2)
+    y.set_value(-2)
+
+    problem.minimize((x - 2) ** 2 + y**2)
+
+    problem.subject_to((1 - x) ** 3 >= y)
+    problem.subject_to(x >= 0)
+    problem.subject_to(y >= 0)
+
+    assert problem.cost_function_type() == ExpressionType.QUADRATIC
+    assert problem.equality_constraint_type() == ExpressionType.NONE
+    assert problem.inequality_constraint_type() == ExpressionType.NONLINEAR
+
+    assert problem.solve(diagnostics=True) == ExitStatus.SUCCESS
+
+    # The solution has no finite Lagrange multipliers, so the iterates only
+    # approach it to within the square root of the tolerance
+    assert x.value() == pytest.approx(1.0, abs=1e-4)
+    assert y.value() == pytest.approx(0.0, abs=1e-4)