sleipnirgroup-jormungandr 0.6.5.dev2__tar.gz → 0.6.5.dev4__tar.gz

{sleipnirgroup_jormungandr-0.6.5.dev2 → sleipnirgroup_jormungandr-0.6.5.dev4}/PKG-INFO

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

{sleipnirgroup_jormungandr-0.6.5.dev2 → sleipnirgroup_jormungandr-0.6.5.dev4}/include/sleipnir/optimization/solver/interior_point.hpp

@@ -467,7 +467,7 @@ ExitStatus interior_point(
     kkt_matrix_decomp_profiler.stop();
     ScopedProfiler kkt_system_solve_profiler{kkt_system_solve_prof};
 
-    auto compute_step = [&](Step& step) {
+    auto compute_step = [&](Step& step, const DenseVector& c_i_minus_s) {
       // p = [ pˣ]
       //     [−pʸ]
       DenseVector p = solver.solve(rhs);
@@ -475,11 +475,11 @@ ExitStatus interior_point(
       step.p_y = -p.segment(x.rows(), y.rows());
 
       // pˢ = cᵢ − s + Aᵢpˣ
-      // pᶻ = −Σcᵢ + μS⁻¹e − ΣAᵢpˣ
-      step.p_s = c_i - s + A_i * step.p_x;
-      step.p_z = -Σ * c_i + μ * s.cwiseInverse() - Σ * A_i * step.p_x;
+      // pᶻ = μS⁻¹e − z − Σpˢ
+      step.p_s = c_i_minus_s + A_i * step.p_x;
+      step.p_z = μ * s.cwiseInverse() - z - Σ * step.p_s;
     };
-    compute_step(step);
+    compute_step(step, c_i - s);
 
     kkt_system_solve_profiler.stop();
     ScopedProfiler line_search_profiler{line_search_prof};
@@ -498,6 +498,14 @@ ExitStatus interior_point(
 
     const FilterEntry<Scalar> current_entry{f, s, c_e, c_i, μ};
 
+    // Compute the directional derivative of the log-barrier function along the
+    // search direction.
+    //
+    // ϕ_μ(x, s) = f(x) − μ∑ᵢ ln(sᵢ)
+    // D_ϕ = ∇ϕ_μ(x, s)ᵀ[pˣ pˢ] = ∇f(x)ᵀpˣ − μ∑ᵢ pᵢˢ/sᵢ
+    const Scalar D_ϕ =
+        g.transpose() * step.p_x - μ * s.cwiseInverse().dot(step.p_s);
+
     // Loop until a step is accepted
     while (1) {
       trial_x = x + α * step.p_x;
@@ -533,7 +541,7 @@ ExitStatus interior_point(
 
       // 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, α)) {
+      if (filter.try_add(current_entry, trial_entry, D_ϕ, α)) {
         // Accept step
         break;
       }
@@ -556,6 +564,7 @@ ExitStatus interior_point(
         Scalar α_soc = α;
         Scalar α_z_soc = α_z;
         DenseVector c_e_soc = c_e;
+        DenseVector c_i_minus_s_soc = c_i - s;
 
         Scalar soc_constraint_violation = next_constraint_violation;
 
@@ -589,15 +598,23 @@ ExitStatus interior_point(
 
           // Rebuild Newton-KKT rhs with updated constraint values.
           //
-          // rhs = −[∇f − Aₑᵀy − Aᵢᵀ(−Σcᵢ + μS⁻¹e + z)]
-          //        [              cₑˢᵒᶜ              ]
+          // rhs = −[∇f − Aₑᵀy − Aᵢᵀ(μS⁻¹e − Σ(cᵢ − s)ˢᵒᶜ)]
+          //        [               cₑˢᵒᶜ                 ]
+          //
+          // where
           //
-          // where cₑˢᵒᶜ = αc(xₖ) + c(xₖ + αpₖˣ)
+          // cₑˢᵒᶜ = αˢᵒᶜcₑ(xₖ) + cₑ(xₖ + αˢᵒᶜpˣˢᵒᶜ)
+          // (cᵢ − s)ˢᵒᶜ = αˢᵒᶜ(cᵢ(xₖ) − sₖ) + cᵢ(xₖ + αˢᵒᶜpˣˢᵒᶜ)
+          //                                 − (sₖ + αˢᵒᶜpˢˢᵒᶜ).
           c_e_soc = α_soc * c_e_soc + trial_c_e;
-          rhs.bottomRows(y.rows()) = -c_e_soc;
+          c_i_minus_s_soc = α_soc * c_i_minus_s_soc + trial_c_i - trial_s;
+          rhs.segment(0, x.rows()) =
+              -g + A_e.transpose() * y +
+              A_i.transpose() * (μ * s.cwiseInverse() - Σ * c_i_minus_s_soc);
+          rhs.segment(x.rows(), y.rows()) = -c_e_soc;
 
           // Solve the Newton-KKT system
-          compute_step(soc_step);
+          compute_step(soc_step, c_i_minus_s_soc);
 
           // αˢᵒᶜ = max(α ∈ (0, 1] : sₖ + αpₖˢ ≥ (1−τⱼ)sₖ)
           // αₖᶻˢᵒᶜ = max(α ∈ (0, 1] : zₖ + αpₖᶻ ≥ (1−τⱼ)zₖ)
@@ -615,7 +632,7 @@ ExitStatus interior_point(
 
           // 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, α)) {
+          if (filter.try_add(current_entry, trial_entry, D_ϕ, α)) {
             step = soc_step;
             α = α_soc;
             α_z = α_z_soc;
@@ -729,9 +746,11 @@ ExitStatus interior_point(
         // is accepted by the normal filter, stop feasibility restoration
         FilterEntry trial_entry{matrices.f(trial_x), trial_s, trial_c_e,
                                 trial_c_i, μ};
+        const Scalar D_ϕ_restoration = g.transpose() * (trial_x - x) -
+                                       μ * s.cwiseInverse().dot(trial_s - s);
         return trial_entry.constraint_violation <
                    Scalar(0.9) * initial_entry.constraint_violation &&
-               filter.try_add(initial_entry, trial_entry, trial_x - x, g, α);
+               filter.try_add(initial_entry, trial_entry, D_ϕ_restoration, α);
       });
       auto status =
           feasibility_restoration<Scalar>(matrices, callbacks, options,

{sleipnirgroup_jormungandr-0.6.5.dev2 → sleipnirgroup_jormungandr-0.6.5.dev4}/include/sleipnir/optimization/solver/newton.hpp

@@ -195,6 +195,7 @@ ExitStatus newton(
 
     constexpr Scalar α_max(1);
     Scalar α = α_max;
+    const Scalar D_ϕ = g.transpose() * p_x;
 
     // Loop until a step is accepted. If a step becomes acceptable, the loop
     // will exit early.
@@ -215,7 +216,7 @@ ExitStatus newton(
       }
 
       // Check whether filter accepts trial iterate
-      if (filter.try_add(FilterEntry{f}, FilterEntry{trial_f}, p_x, g, α)) {
+      if (filter.try_add(FilterEntry{f}, FilterEntry{trial_f}, D_ϕ, α)) {
         // Accept step
         break;
       }

{sleipnirgroup_jormungandr-0.6.5.dev2 → sleipnirgroup_jormungandr-0.6.5.dev4}/include/sleipnir/optimization/solver/sqp.hpp

@@ -339,6 +339,7 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
     α = α_max;
 
     const FilterEntry<Scalar> current_entry{f, c_e};
+    const Scalar D_ϕ = g.transpose() * step.p_x;
 
     // Loop until a step is accepted
     while (1) {
@@ -363,7 +364,7 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
 
       // Check whether filter accepts trial iterate
       FilterEntry trial_entry{trial_f, trial_c_e};
-      if (filter.try_add(current_entry, trial_entry, step.p_x, g, α)) {
+      if (filter.try_add(current_entry, trial_entry, D_ϕ, α)) {
         // Accept step
         break;
       }
@@ -428,7 +429,7 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
 
           // Check whether the filter accepts trial iterate
           FilterEntry trial_entry{trial_f, trial_c_e};
-          if (filter.try_add(current_entry, trial_entry, step.p_x, g, α)) {
+          if (filter.try_add(current_entry, trial_entry, D_ϕ, α)) {
             step = soc_step;
             α = α_soc;
             step_acceptable = true;
@@ -524,12 +525,13 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
         DenseVector trial_c_e = matrices.c_e(trial_x);
 
         FilterEntry trial_entry{matrices.f(trial_x), trial_c_e};
+        const Scalar D_ϕ_restoration = g.transpose() * (trial_x - x);
 
         // If the current iterate sufficiently reduces constraint violation and
         // is accepted by the normal filter, stop feasibility restoration
         return trial_entry.constraint_violation <
                    Scalar(0.9) * initial_entry.constraint_violation &&
-               filter.try_add(initial_entry, trial_entry, trial_x - x, g, α);
+               filter.try_add(initial_entry, trial_entry, D_ϕ_restoration, α);
       });
       auto status = feasibility_restoration<Scalar>(matrices, callbacks,
                                                     options, x, y, iterations);

{sleipnirgroup_jormungandr-0.6.5.dev2 → sleipnirgroup_jormungandr-0.6.5.dev4}/include/sleipnir/optimization/solver/util/filter.hpp

@@ -6,7 +6,6 @@
 #include <cmath>
 
 #include <Eigen/Core>
-#include <Eigen/SparseCore>
 #include <gch/small_vector.hpp>
 
 // See docs/algorithms.md#Works_cited for citation definitions.
@@ -75,12 +74,6 @@ struct FilterEntry {
 template <typename Scalar>
 class Filter {
  public:
-  /// Type alias for dense vector.
-  using DenseVector = Eigen::Vector<Scalar, Eigen::Dynamic>;
-
-  /// Type alias for sparse vector.
-  using SparseVector = Eigen::SparseVector<Scalar>;
-
   /// The minimum constraint violation
   Scalar min_constraint_violation;
 
@@ -110,13 +103,11 @@ class Filter {
   ///
   /// @param current_entry The entry corresponding to the current iterate.
   /// @param trial_entry The entry corresponding to the trial iterate.
-  /// @param p_x Decision variable primal step.
-  /// @param g Cost function gradient.
+  /// @param D_ϕ Cost directional derivative along the search direction.
   /// @param α The step size (0, 1].
   /// @return True if the given entry is acceptable to the filter.
   bool try_add(const FilterEntry<Scalar>& current_entry,
-               const FilterEntry<Scalar>& trial_entry, const DenseVector& p_x,
-               const SparseVector& g, Scalar α) {
+               const FilterEntry<Scalar>& trial_entry, Scalar D_ϕ, Scalar α) {
     using std::isfinite;
     using std::pow;
 
@@ -126,19 +117,17 @@ class Filter {
       return false;
     }
 
-    Scalar g_p_x = g.transpose() * p_x;
-
     // Switching condition
     constexpr Scalar s_ϕ(2.3);
     constexpr Scalar s_θ(1.1);
     bool switching_condition =
-        g_p_x < Scalar(0) &&
-        α * pow(-g_p_x, s_ϕ) > pow(current_entry.constraint_violation, s_θ);
+        D_ϕ < Scalar(0) &&
+        α * pow(-D_ϕ, s_ϕ) > pow(current_entry.constraint_violation, s_θ);
 
     // Armijo condition
     constexpr Scalar η_ϕ(1e-8);
     bool armijo_condition =
-        trial_entry.cost <= current_entry.cost + η_ϕ * α * g_p_x;
+        trial_entry.cost <= current_entry.cost + η_ϕ * α * D_ϕ;
 
     // Sufficient decrease condition
     //

{sleipnirgroup_jormungandr-0.6.5.dev2 → sleipnirgroup_jormungandr-0.6.5.dev4}/python/src/sleipnir/__init__.py

@@ -2,4 +2,4 @@
 
 from ._sleipnir import *
 
-__version__ = "0.6.5.dev2"
+__version__ = "0.6.5.dev4"