sleipnirgroup-jormungandr 0.5.4.dev3__tar.gz → 0.5.4.dev5__tar.gz

{sleipnirgroup_jormungandr-0.5.4.dev3 → sleipnirgroup_jormungandr-0.5.4.dev5}/PKG-INFO

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

{sleipnirgroup_jormungandr-0.5.4.dev3 → sleipnirgroup_jormungandr-0.5.4.dev5}/include/sleipnir/optimization/solver/interior_point.hpp

@@ -6,7 +6,6 @@
 #include <chrono>
 #include <cmath>
 #include <functional>
-#include <limits>
 #include <span>
 
 #include <Eigen/Core>
@@ -259,6 +258,15 @@ ExitStatus interior_point(
   slp_assert(A_i.rows() == matrices.num_inequality_constraints);
   slp_assert(A_i.cols() == matrices.num_decision_variables);
 
+  DenseVector trial_x;
+  DenseVector trial_s;
+  DenseVector trial_y;
+  DenseVector trial_z;
+
+  Scalar trial_f;
+  DenseVector trial_c_e;
+  DenseVector trial_c_i;
+
   // Check for overconstrained problem
   if (matrices.num_equality_constraints > matrices.num_decision_variables) {
     if (options.diagnostics) {
@@ -338,7 +346,8 @@ ExitStatus interior_point(
   int full_step_rejected_counter = 0;
 
   // Error
-  Scalar E_0 = std::numeric_limits<Scalar>::infinity();
+  Scalar E_0 = kkt_error<Scalar, KKTErrorType::INF_NORM_SCALED>(
+      g, A_e, c_e, A_i, c_i, s, y, z, Scalar(0));
 
   setup_prof.stop();
 
@@ -479,13 +488,22 @@ ExitStatus interior_point(
 
     // Loop until a step is accepted
     while (1) {
-      DenseVector trial_x = x + α * step.p_x;
-      DenseVector trial_y = y + α_z * step.p_y;
-      DenseVector trial_z = z + α_z * step.p_z;
+      trial_x = x + α * step.p_x;
+      if (options.feasible_ipm && c_i.cwiseGreater(Scalar(0)).all()) {
+        // If the inequality constraints are all feasible, prevent them from
+        // becoming infeasible again.
+        //
+        // See equation (19.30) in [1].
+        trial_s = trial_c_i;
+      } else {
+        trial_s = s + α * step.p_s;
+      }
+      trial_y = y + α_z * step.p_y;
+      trial_z = z + α_z * step.p_z;
 
-      Scalar trial_f = matrices.f(trial_x);
-      DenseVector trial_c_e = matrices.c_e(trial_x);
-      DenseVector trial_c_i = matrices.c_i(trial_x);
+      trial_f = matrices.f(trial_x);
+      trial_c_e = matrices.c_e(trial_x);
+      trial_c_i = matrices.c_i(trial_x);
 
       // If f(xₖ + αpₖˣ), cₑ(xₖ + αpₖˣ), or cᵢ(xₖ + αpₖˣ) aren't finite, reduce
       // step size immediately
@@ -501,17 +519,6 @@ ExitStatus interior_point(
         continue;
       }
 
-      DenseVector trial_s;
-      if (options.feasible_ipm && c_i.cwiseGreater(Scalar(0)).all()) {
-        // If the inequality constraints are all feasible, prevent them from
-        // becoming infeasible again.
-        //
-        // See equation (19.30) in [1].
-        trial_s = trial_c_i;
-      } else {
-        trial_s = s + α * step.p_s;
-      }
-
       // Check whether filter accepts trial iterate
       FilterEntry trial_entry{trial_f, trial_s, trial_c_e, trial_c_i, μ};
       if (filter.try_add(current_entry, trial_entry, step.p_x, g, α)) {
@@ -576,12 +583,12 @@ ExitStatus interior_point(
           compute_step(soc_step);
 
           // αˢᵒᶜ = max(α ∈ (0, 1] : sₖ + αpₖˢ ≥ (1−τⱼ)sₖ)
+          // αₖᶻˢᵒᶜ = max(α ∈ (0, 1] : zₖ + αpₖᶻ ≥ (1−τⱼ)zₖ)
           α_soc = fraction_to_the_boundary_rule<Scalar>(s, soc_step.p_s, τ);
+          α_z_soc = fraction_to_the_boundary_rule<Scalar>(z, soc_step.p_z, τ);
+
           trial_x = x + α_soc * soc_step.p_x;
           trial_s = s + α_soc * soc_step.p_s;
-
-          // αₖᶻ = max(α ∈ (0, 1] : zₖ + αpₖᶻ ≥ (1−τⱼ)zₖ)
-          α_z_soc = fraction_to_the_boundary_rule<Scalar>(z, soc_step.p_z, τ);
           trial_y = y + α_z_soc * soc_step.p_y;
           trial_z = z + α_z_soc * soc_step.p_z;
 
@@ -648,21 +655,19 @@ ExitStatus interior_point(
 
         trial_x = x + α_max * step.p_x;
         trial_s = s + α_max * step.p_s;
-
         trial_y = y + α_z * step.p_y;
         trial_z = z + α_z * step.p_z;
 
+        trial_f = matrices.f(trial_x);
         trial_c_e = matrices.c_e(trial_x);
         trial_c_i = matrices.c_i(trial_x);
 
         Scalar next_kkt_error = kkt_error<Scalar, KKTErrorType::ONE_NORM>(
-            matrices.g(trial_x), matrices.A_e(trial_x), matrices.c_e(trial_x),
+            matrices.g(trial_x), matrices.A_e(trial_x), trial_c_e,
             matrices.A_i(trial_x), trial_c_i, trial_s, trial_y, trial_z, μ);
 
         // If the step using αᵐᵃˣ reduced the KKT error, accept it anyway
         if (next_kkt_error <= Scalar(0.999) * current_kkt_error) {
-          α = α_max;
-
           // Accept step
           break;
         }
@@ -718,14 +723,11 @@ ExitStatus interior_point(
         full_step_rejected_counter = 0;
       }
 
-      // xₖ₊₁ = xₖ + αₖpₖˣ
-      // sₖ₊₁ = sₖ + αₖpₖˢ
-      // yₖ₊₁ = yₖ + αₖᶻpₖʸ
-      // zₖ₊₁ = zₖ + αₖᶻpₖᶻ
-      x += α * step.p_x;
-      s += α * step.p_s;
-      y += α_z * step.p_y;
-      z += α_z * step.p_z;
+      // Update iterates
+      x = trial_x;
+      s = trial_s;
+      y = trial_y;
+      z = trial_z;
 
       // A requirement for the convergence proof is that the primal-dual barrier
       // term Hessian Σₖ₊₁ does not deviate arbitrarily much from the primal
@@ -748,7 +750,6 @@ ExitStatus interior_point(
     }
 
     // Update autodiff for Jacobians and Hessian
-    f = matrices.f(x);
     A_e = matrices.A_e(x);
     A_i = matrices.A_i(x);
     g = matrices.g(x);
@@ -756,8 +757,9 @@ ExitStatus interior_point(
 
     ScopedProfiler next_iter_prep_profiler{next_iter_prep_prof};
 
-    c_e = matrices.c_e(x);
-    c_i = matrices.c_i(x);
+    f = trial_f;
+    c_e = trial_c_e;
+    c_i = trial_c_i;
 
     // Update the error
     E_0 = kkt_error<Scalar, KKTErrorType::INF_NORM_SCALED>(

{sleipnirgroup_jormungandr-0.5.4.dev3 → sleipnirgroup_jormungandr-0.5.4.dev5}/include/sleipnir/optimization/solver/newton.hpp

@@ -5,7 +5,6 @@
 #include <chrono>
 #include <cmath>
 #include <functional>
-#include <limits>
 #include <span>
 
 #include <Eigen/Core>
@@ -122,6 +121,10 @@ ExitStatus newton(
   slp_assert(H.rows() == matrices.num_decision_variables);
   slp_assert(H.cols() == matrices.num_decision_variables);
 
+  DenseVector trial_x;
+
+  Scalar trial_f;
+
   // Check whether initial guess has finite cost and derivatives
   if (!isfinite(f) || !all_finite(g) || !all_finite(H)) {
     return ExitStatus::NONFINITE_INITIAL_GUESS;
@@ -138,7 +141,7 @@ ExitStatus newton(
   constexpr Scalar α_min(1e-20);
 
   // Error
-  Scalar E_0 = std::numeric_limits<Scalar>::infinity();
+  Scalar E_0 = kkt_error<Scalar, KKTErrorType::INF_NORM_SCALED>(g);
 
   setup_prof.stop();
 
@@ -194,9 +197,9 @@ ExitStatus newton(
     // Loop until a step is accepted. If a step becomes acceptable, the loop
     // will exit early.
     while (1) {
-      DenseVector trial_x = x + α * p_x;
+      trial_x = x + α * p_x;
 
-      Scalar trial_f = matrices.f(trial_x);
+      trial_f = matrices.f(trial_x);
 
       // If f(xₖ + αpₖˣ) isn't finite, reduce step size immediately
       if (!isfinite(trial_f)) {
@@ -223,14 +226,14 @@ ExitStatus newton(
       if (α < α_min) {
         Scalar current_kkt_error = kkt_error<Scalar, KKTErrorType::ONE_NORM>(g);
 
-        DenseVector trial_x = x + α_max * p_x;
+        trial_x = x + α_max * p_x;
 
         Scalar next_kkt_error =
             kkt_error<Scalar, KKTErrorType::ONE_NORM>(matrices.g(trial_x));
 
         // If the step using αᵐᵃˣ reduced the KKT error, accept it anyway
         if (next_kkt_error <= Scalar(0.999) * current_kkt_error) {
-          α = α_max;
+          trial_f = matrices.f(trial_x);
 
           // Accept step
           break;
@@ -242,16 +245,17 @@ ExitStatus newton(
 
     line_search_profiler.stop();
 
-    // xₖ₊₁ = xₖ + αₖpₖˣ
-    x += α * p_x;
+    // Update iterates
+    x = trial_x;
 
     // Update autodiff for Hessian
-    f = matrices.f(x);
     g = matrices.g(x);
     H = matrices.H(x);
 
     ScopedProfiler next_iter_prep_profiler{next_iter_prep_prof};
 
+    f = trial_f;
+
     // Update the error
     E_0 = kkt_error<Scalar, KKTErrorType::INF_NORM_SCALED>(g);
 

{sleipnirgroup_jormungandr-0.5.4.dev3 → sleipnirgroup_jormungandr-0.5.4.dev5}/include/sleipnir/optimization/solver/sqp.hpp

@@ -5,7 +5,6 @@
 #include <chrono>
 #include <cmath>
 #include <functional>
-#include <limits>
 #include <span>
 
 #include <Eigen/Core>
@@ -198,6 +197,12 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
   slp_assert(A_e.rows() == matrices.num_equality_constraints);
   slp_assert(A_e.cols() == matrices.num_decision_variables);
 
+  DenseVector trial_x;
+  DenseVector trial_y;
+
+  Scalar trial_f;
+  DenseVector trial_c_e;
+
   // Check for overconstrained problem
   if (matrices.num_equality_constraints > matrices.num_decision_variables) {
     if (options.diagnostics) {
@@ -230,7 +235,7 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
   int full_step_rejected_counter = 0;
 
   // Error
-  Scalar E_0 = std::numeric_limits<Scalar>::infinity();
+  Scalar E_0 = kkt_error<Scalar, KKTErrorType::INF_NORM_SCALED>(g, A_e, c_e, y);
 
   setup_prof.stop();
 
@@ -331,11 +336,11 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
 
     // Loop until a step is accepted
     while (1) {
-      DenseVector trial_x = x + α * step.p_x;
-      DenseVector trial_y = y + α * step.p_y;
+      trial_x = x + α * step.p_x;
+      trial_y = y + α * step.p_y;
 
-      Scalar trial_f = matrices.f(trial_x);
-      DenseVector trial_c_e = matrices.c_e(trial_x);
+      trial_f = matrices.f(trial_x);
+      trial_c_e = matrices.c_e(trial_x);
 
       // If f(xₖ + αpₖˣ) or cₑ(xₖ + αpₖˣ) aren't finite, reduce step size
       // immediately
@@ -469,6 +474,7 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
         trial_x = x + α_max * step.p_x;
         trial_y = y + α_max * step.p_y;
 
+        trial_f = matrices.f(trial_x);
         trial_c_e = matrices.c_e(trial_x);
 
         Scalar next_kkt_error = kkt_error<Scalar, KKTErrorType::ONE_NORM>(
@@ -476,8 +482,6 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
 
         // If the step using αᵐᵃˣ reduced the KKT error, accept it anyway
         if (next_kkt_error <= Scalar(0.999) * current_kkt_error) {
-          α = α_max;
-
           // Accept step
           break;
         }
@@ -525,20 +529,19 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
         full_step_rejected_counter = 0;
       }
 
-      // xₖ₊₁ = xₖ + αₖpₖˣ
-      // yₖ₊₁ = yₖ + αₖpₖʸ
-      x += α * step.p_x;
-      y += α * step.p_y;
+      // Update iterates
+      x = trial_x;
+      y = trial_y;
     }
 
     // Update autodiff for Jacobians and Hessian
-    f = matrices.f(x);
     A_e = matrices.A_e(x);
     g = matrices.g(x);
     H = matrices.H(x, y);
 
     ScopedProfiler next_iter_prep_profiler{next_iter_prep_prof};
 
+    f = trial_f;
     c_e = matrices.c_e(x);
 
     // Update the error

{sleipnirgroup_jormungandr-0.5.4.dev3 → sleipnirgroup_jormungandr-0.5.4.dev5}/python/src/sleipnir/__init__.py

@@ -2,4 +2,4 @@
 
 from ._sleipnir import *
 
-__version__ = "0.5.4.dev3"
+__version__ = "0.5.4.dev5"

{sleipnirgroup_jormungandr-0.5.4.dev3 → sleipnirgroup_jormungandr-0.5.4.dev5}/python/test/optimization/solver/exit_status_test.py

@@ -6,19 +6,20 @@ from sleipnir.optimization import ExitStatus, Problem
 
 def test_callback_requested_stop():
     problem = Problem()
-
     x = problem.decision_variable()
-
     problem.minimize(x * x)
 
     problem.add_callback(lambda info: False)
+    x.set_value(1)
     assert problem.solve(diagnostics=True) == ExitStatus.SUCCESS
 
     problem.add_callback(lambda info: True)
+    x.set_value(1)
     assert problem.solve(diagnostics=True) == ExitStatus.CALLBACK_REQUESTED_STOP
 
     problem.clear_callbacks()
     problem.add_callback(lambda info: False)
+    x.set_value(1)
     assert problem.solve(diagnostics=True) == ExitStatus.SUCCESS
 
 
@@ -137,6 +138,7 @@ def test_max_iterations_exceeded():
     problem = Problem()
 
     x = problem.decision_variable()
+    x.set_value(1)
 
     problem.minimize(x * x)
 
@@ -154,6 +156,7 @@ def test_timeout():
     problem = Problem()
 
     x = problem.decision_variable()
+    x.set_value(1)
 
     problem.minimize(x * x)