sleipnirgroup-jormungandr 0.6.7.dev132__tar.gz → 0.6.7.dev134__tar.gz

{sleipnirgroup_jormungandr-0.6.7.dev132 → sleipnirgroup_jormungandr-0.6.7.dev134}/PKG-INFO

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

{sleipnirgroup_jormungandr-0.6.7.dev132 → sleipnirgroup_jormungandr-0.6.7.dev134}/cmake/CompilerFlags.cmake

@@ -4,12 +4,8 @@ function(compiler_flags target)
 
         if(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
             # Suppress the following warnings:
-            #   * -Warray-bounds= (false positives)
             #   * -Wpsabi (notes about a GCC 10.1 ABI change on aarch64)
-            target_compile_options(
-                ${target}
-                PRIVATE -Wno-array-bounds -Wno-psabi
-            )
+            target_compile_options(${target} PRIVATE -Wno-psabi)
         endif()
     else()
         # Suppress the following warnings:

{sleipnirgroup_jormungandr-0.6.7.dev132 → sleipnirgroup_jormungandr-0.6.7.dev134}/include/sleipnir/optimization/problem.hpp

@@ -24,6 +24,7 @@
 #include "sleipnir/autodiff/jacobian.hpp"
 #include "sleipnir/autodiff/variable.hpp"
 #include "sleipnir/autodiff/variable_matrix.hpp"
+#include "sleipnir/optimization/solver/control_flow.hpp"
 #include "sleipnir/optimization/solver/exit_status.hpp"
 #include "sleipnir/optimization/solver/ipm.hpp"
 #include "sleipnir/optimization/solver/ipm_matrix_callbacks.hpp"
@@ -352,19 +353,19 @@ class Problem {
         [=, callback =
                 std::forward<F>(callback)](const IterationInfo<Scalar>& info) {
           callback(info);
-          return false;
+          return ControlFlow::CONTINUE;
         });
   }
 
   /// Adds a callback to be called at the beginning of each solver iteration.
   ///
-  /// The callback for this overload should return bool.
+  /// The callback for this overload should return ControlFlow.
   ///
-  /// @param callback The callback. Returning true from the callback causes the
-  ///     solver to exit early with the solution it has so far.
+  /// @param callback The callback. Returning ControlFlow::BREAK from the
+  ///     callback stops solving and returns the solution so far.
   template <typename F>
     requires requires(F callback, const IterationInfo<Scalar>& info) {
-      { callback(info) } -> std::same_as<bool>;
+      { callback(info) } -> std::same_as<ControlFlow>;
     }
   void add_callback(F&& callback) {
     m_iteration_callbacks.emplace_back(std::forward<F>(callback));
@@ -379,11 +380,11 @@ class Problem {
   /// callbacks that shouldn't be removed by clear_callbacks(). Persistent
   /// callbacks run after non-persistent callbacks.
   ///
-  /// @param callback The callback. Returning true from the callback causes the
-  ///     solver to exit early with the solution it has so far.
+  /// @param callback The callback. Returning ControlFlow::BREAK from the
+  ///     callback stops solving and returns the solution so far.
   template <typename F>
     requires requires(F callback, const IterationInfo<Scalar>& info) {
-      { callback(info) } -> std::same_as<bool>;
+      { callback(info) } -> std::same_as<ControlFlow>;
     }
   void add_persistent_callback(F&& callback) {
     m_persistent_iteration_callbacks.emplace_back(std::forward<F>(callback));
@@ -406,9 +407,11 @@ class Problem {
   gch::small_vector<Variable<Scalar>> m_inequality_constraints;
 
   // The iteration callbacks
-  gch::small_vector<std::function<bool(const IterationInfo<Scalar>& info)>>
+  gch::small_vector<
+      std::function<ControlFlow(const IterationInfo<Scalar>& info)>>
       m_iteration_callbacks;
-  gch::small_vector<std::function<bool(const IterationInfo<Scalar>& info)>>
+  gch::small_vector<
+      std::function<ControlFlow(const IterationInfo<Scalar>& info)>>
       m_persistent_iteration_callbacks;
 
   ExitStatus solve_newton(const Options<Scalar>& options,
@@ -424,7 +427,8 @@ class Problem {
 
     int num_decision_variables = m_decision_variables.size();
 
-    gch::small_vector<std::function<bool(const IterationInfo<Scalar>& info)>>
+    gch::small_vector<
+        std::function<ControlFlow(const IterationInfo<Scalar>& info)>>
         iteration_callbacks;
     for (const auto& callback : m_iteration_callbacks) {
       iteration_callbacks.emplace_back(callback);
@@ -460,11 +464,10 @@ class Problem {
       H_spy = std::make_unique<Spy<Scalar>>(
           "H.spy", "Hessian", "Decision variables", "Decision variables",
           num_decision_variables, num_decision_variables);
-      iteration_callbacks.push_back(
-          [&](const IterationInfo<Scalar>& info) -> bool {
-            H_spy->add(info.H);
-            return false;
-          });
+      iteration_callbacks.push_back([&](const IterationInfo<Scalar>& info) {
+        H_spy->add(info.H);
+        return ControlFlow::CONTINUE;
+      });
     }
 #endif
 
@@ -507,7 +510,8 @@ class Problem {
     int num_decision_variables = m_decision_variables.size();
     int num_equality_constraints = m_equality_constraints.size();
 
-    gch::small_vector<std::function<bool(const IterationInfo<Scalar>& info)>>
+    gch::small_vector<
+        std::function<ControlFlow(const IterationInfo<Scalar>& info)>>
         iteration_callbacks;
     for (const auto& callback : m_iteration_callbacks) {
       iteration_callbacks.emplace_back(callback);
@@ -563,12 +567,11 @@ class Problem {
           "A_e.spy", "Equality constraint Jacobian", "Constraints",
           "Decision variables", num_equality_constraints,
           num_decision_variables);
-      iteration_callbacks.push_back(
-          [&](const IterationInfo<Scalar>& info) -> bool {
-            H_spy->add(info.H);
-            A_e_spy->add(info.A_e);
-            return false;
-          });
+      iteration_callbacks.push_back([&](const IterationInfo<Scalar>& info) {
+        H_spy->add(info.H);
+        A_e_spy->add(info.A_e);
+        return ControlFlow::CONTINUE;
+      });
     }
 #endif
 
@@ -628,7 +631,8 @@ class Problem {
     int num_equality_constraints = m_equality_constraints.size();
     int num_inequality_constraints = m_inequality_constraints.size();
 
-    gch::small_vector<std::function<bool(const IterationInfo<Scalar>& info)>>
+    gch::small_vector<
+        std::function<ControlFlow(const IterationInfo<Scalar>& info)>>
         iteration_callbacks;
     for (const auto& callback : m_iteration_callbacks) {
       iteration_callbacks.emplace_back(callback);
@@ -696,13 +700,12 @@ class Problem {
           "A_i.spy", "Inequality constraint Jacobian", "Constraints",
           "Decision variables", num_inequality_constraints,
           num_decision_variables);
-      iteration_callbacks.push_back(
-          [&](const IterationInfo<Scalar>& info) -> bool {
-            H_spy->add(info.H);
-            A_e_spy->add(info.A_e);
-            A_i_spy->add(info.A_i);
-            return false;
-          });
+      iteration_callbacks.push_back([&](const IterationInfo<Scalar>& info) {
+        H_spy->add(info.H);
+        A_e_spy->add(info.A_e);
+        A_i_spy->add(info.A_i);
+        return ControlFlow::CONTINUE;
+      });
     }
 #endif
 

sleipnirgroup_jormungandr-0.6.7.dev134/include/sleipnir/optimization/solver/control_flow.hpp

@@ -0,0 +1,17 @@
+// Copyright (c) Sleipnir contributors
+
+#pragma once
+
+#include <stdint.h>
+
+namespace slp {
+
+/// Solver control flow returned by an iteration callback.
+enum class ControlFlow : uint8_t {
+  /// Continue solving.
+  CONTINUE,
+  /// Stop solving and return the solution so far.
+  BREAK,
+};
+
+}  // namespace slp

{sleipnirgroup_jormungandr-0.6.7.dev132 → sleipnirgroup_jormungandr-0.6.7.dev134}/include/sleipnir/optimization/solver/ipm.hpp

@@ -14,6 +14,7 @@
 #include <Eigen/SparseCore>
 #include <gch/small_vector.hpp>
 
+#include "sleipnir/optimization/solver/control_flow.hpp"
 #include "sleipnir/optimization/solver/exit_status.hpp"
 #include "sleipnir/optimization/solver/ipm_matrix_callbacks.hpp"
 #include "sleipnir/optimization/solver/iteration_info.hpp"
@@ -65,14 +66,15 @@ namespace slp {
 ///     variables.
 /// @return The exit status.
 template <typename Scalar>
-ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
-               std::span<std::function<bool(const IterationInfo<Scalar>& info)>>
-                   iteration_callbacks,
-               const Options<Scalar>& options,
+ExitStatus ipm(
+    const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
+    std::span<std::function<ControlFlow(const IterationInfo<Scalar>& info)>>
+        iteration_callbacks,
+    const Options<Scalar>& options,
 #ifdef SLEIPNIR_ENABLE_BOUND_PROJECTION
-               const Eigen::ArrayX<bool>& bound_constraint_mask,
+    const Eigen::ArrayX<bool>& bound_constraint_mask,
 #endif
-               Eigen::VectorX<Scalar>& x) {
+    Eigen::VectorX<Scalar>& x) {
   using DenseVector = Eigen::VectorX<Scalar>;
 
   // If cᵢ(x) is sufficiently feasible, start the constraint with zero
@@ -127,16 +129,17 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
 /// @param[in,out] iterations The iteration counter.
 /// @return The exit status.
 template <typename Scalar>
-ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
-               std::span<std::function<bool(const IterationInfo<Scalar>& info)>>
-                   iteration_callbacks,
-               const Options<Scalar>& options, bool in_feasibility_restoration,
+ExitStatus ipm(
+    const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
+    std::span<std::function<ControlFlow(const IterationInfo<Scalar>& info)>>
+        iteration_callbacks,
+    const Options<Scalar>& options, bool in_feasibility_restoration,
 #ifdef SLEIPNIR_ENABLE_BOUND_PROJECTION
-               const Eigen::ArrayX<bool>& bound_constraint_mask,
+    const Eigen::ArrayX<bool>& bound_constraint_mask,
 #endif
-               Eigen::VectorX<Scalar>& x, Eigen::VectorX<Scalar>& s,
-               Eigen::VectorX<Scalar>& y, Eigen::VectorX<Scalar>& z, Scalar& μ,
-               int& iterations) {
+    Eigen::VectorX<Scalar>& x, Eigen::VectorX<Scalar>& s,
+    Eigen::VectorX<Scalar>& y, Eigen::VectorX<Scalar>& z, Scalar& μ,
+    int& iterations) {
   using DenseVector = Eigen::VectorX<Scalar>;
   using SparseMatrix = Eigen::SparseMatrix<Scalar>;
   using SparseVector = Eigen::SparseVector<Scalar>;
@@ -397,7 +400,8 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
 
     // Call iteration callbacks
     for (const auto& callback : iteration_callbacks) {
-      if (callback({iterations, x, s, y, z, g, H, A_e, A_i})) {
+      if (callback({iterations, x, s, y, z, g, H, A_e, A_i}) ==
+          ControlFlow::BREAK) {
         return ExitStatus::CALLBACK_REQUESTED_STOP;
       }
     }
@@ -728,14 +732,15 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
           feasibility_restoration_cycle_detector.is_cycling();
 
       // Feasibility restoration phase
-      gch::small_vector<std::function<bool(const IterationInfo<Scalar>& info)>>
+      gch::small_vector<
+          std::function<ControlFlow(const IterationInfo<Scalar>& info)>>
           callbacks;
       for (auto& callback : iteration_callbacks) {
         callbacks.emplace_back(callback);
       }
       callbacks.emplace_back([&](const IterationInfo<Scalar>& info) {
         if (run_feasibility_restoration_to_convergence) {
-          return false;
+          return ControlFlow::CONTINUE;
         }
 
         DenseVector trial_x =
@@ -755,9 +760,13 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
         // is accepted by the normal filter, stop feasibility restoration
         FilterEntry trial_entry{matrices.f(trial_x), trial_s, trial_c_e,
                                 trial_c_i, μ};
-        return trial_entry.constraint_violation <
-                   Scalar(0.9) * initial_entry.constraint_violation &&
-               filter.is_acceptable(trial_entry);
+        if (trial_entry.constraint_violation <
+                Scalar(0.9) * initial_entry.constraint_violation &&
+            filter.is_acceptable(trial_entry)) {
+          return ControlFlow::BREAK;
+        } else {
+          return ControlFlow::CONTINUE;
+        }
       });
       auto status =
           feasibility_restoration<Scalar>(matrices, callbacks, options,
@@ -885,7 +894,7 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
 
 extern template SLEIPNIR_DLLEXPORT ExitStatus
 ipm(const IPMMatrixCallbacks<double>& matrix_callbacks,
-    std::span<std::function<bool(const IterationInfo<double>& info)>>
+    std::span<std::function<ControlFlow(const IterationInfo<double>& info)>>
         iteration_callbacks,
     const Options<double>& options,
 #ifdef SLEIPNIR_ENABLE_BOUND_PROJECTION

{sleipnirgroup_jormungandr-0.6.7.dev132 → sleipnirgroup_jormungandr-0.6.7.dev134}/include/sleipnir/optimization/solver/newton.hpp

@@ -13,6 +13,7 @@
 #include <Eigen/Core>
 #include <Eigen/SparseCore>
 
+#include "sleipnir/optimization/solver/control_flow.hpp"
 #include "sleipnir/optimization/solver/exit_status.hpp"
 #include "sleipnir/optimization/solver/iteration_info.hpp"
 #include "sleipnir/optimization/solver/newton_matrix_callbacks.hpp"
@@ -52,7 +53,7 @@ namespace slp {
 template <typename Scalar>
 ExitStatus newton(
     const NewtonMatrixCallbacks<Scalar>& matrix_callbacks,
-    std::span<std::function<bool(const IterationInfo<Scalar>& info)>>
+    std::span<std::function<ControlFlow(const IterationInfo<Scalar>& info)>>
         iteration_callbacks,
     const Options<Scalar>& options, Eigen::VectorX<Scalar>& x) {
   using DenseVector = Eigen::VectorX<Scalar>;
@@ -143,7 +144,8 @@ ExitStatus newton(
 
     // Call iteration callbacks
     for (const auto& callback : iteration_callbacks) {
-      if (callback({iterations, x, {}, {}, {}, g, H, {}, {}})) {
+      if (callback({iterations, x, {}, {}, {}, g, H, {}, {}}) ==
+          ControlFlow::BREAK) {
         return ExitStatus::CALLBACK_REQUESTED_STOP;
       }
     }
@@ -290,7 +292,7 @@ ExitStatus newton(
 
 extern template SLEIPNIR_DLLEXPORT ExitStatus
 newton(const NewtonMatrixCallbacks<double>& matrix_callbacks,
-       std::span<std::function<bool(const IterationInfo<double>& info)>>
+       std::span<std::function<ControlFlow(const IterationInfo<double>& info)>>
            iteration_callbacks,
        const Options<double>& options, Eigen::VectorX<double>& x);
 

{sleipnirgroup_jormungandr-0.6.7.dev132 → sleipnirgroup_jormungandr-0.6.7.dev134}/include/sleipnir/optimization/solver/sqp.hpp

@@ -14,6 +14,7 @@
 #include <Eigen/SparseCore>
 #include <gch/small_vector.hpp>
 
+#include "sleipnir/optimization/solver/control_flow.hpp"
 #include "sleipnir/optimization/solver/exit_status.hpp"
 #include "sleipnir/optimization/solver/iteration_info.hpp"
 #include "sleipnir/optimization/solver/options.hpp"
@@ -58,10 +59,11 @@ namespace slp {
 ///     variables.
 /// @return The exit status.
 template <typename Scalar>
-ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
-               std::span<std::function<bool(const IterationInfo<Scalar>& info)>>
-                   iteration_callbacks,
-               const Options<Scalar>& options, Eigen::VectorX<Scalar>& x) {
+ExitStatus sqp(
+    const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
+    std::span<std::function<ControlFlow(const IterationInfo<Scalar>& info)>>
+        iteration_callbacks,
+    const Options<Scalar>& options, Eigen::VectorX<Scalar>& x) {
   using DenseVector = Eigen::VectorX<Scalar>;
 
   DenseVector y = DenseVector::Zero(matrix_callbacks.num_equality_constraints);
@@ -92,11 +94,12 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
 ///     constraint dual variables.
 /// @return The exit status.
 template <typename Scalar>
-ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
-               std::span<std::function<bool(const IterationInfo<Scalar>& info)>>
-                   iteration_callbacks,
-               const Options<Scalar>& options, Eigen::VectorX<Scalar>& x,
-               Eigen::VectorX<Scalar>& y) {
+ExitStatus sqp(
+    const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
+    std::span<std::function<ControlFlow(const IterationInfo<Scalar>& info)>>
+        iteration_callbacks,
+    const Options<Scalar>& options, Eigen::VectorX<Scalar>& x,
+    Eigen::VectorX<Scalar>& y) {
   using DenseVector = Eigen::VectorX<Scalar>;
   using SparseMatrix = Eigen::SparseMatrix<Scalar>;
   using SparseVector = Eigen::SparseVector<Scalar>;
@@ -268,7 +271,8 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
 
     // Call iteration callbacks
     for (const auto& callback : iteration_callbacks) {
-      if (callback({iterations, x, {}, y, {}, g, H, A_e, {}})) {
+      if (callback({iterations, x, {}, y, {}, g, H, A_e, {}}) ==
+          ControlFlow::BREAK) {
         return ExitStatus::CALLBACK_REQUESTED_STOP;
       }
     }
@@ -522,14 +526,15 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
           feasibility_restoration_cycle_detector.is_cycling();
 
       // Feasibility restoration phase
-      gch::small_vector<std::function<bool(const IterationInfo<Scalar>& info)>>
+      gch::small_vector<
+          std::function<ControlFlow(const IterationInfo<Scalar>& info)>>
           callbacks;
       for (auto& callback : iteration_callbacks) {
         callbacks.emplace_back(callback);
       }
       callbacks.emplace_back([&](const IterationInfo<Scalar>& info) {
         if (run_feasibility_restoration_to_convergence) {
-          return false;
+          return ControlFlow::CONTINUE;
         }
 
         DenseVector trial_x =
@@ -541,9 +546,13 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
 
         // 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.is_acceptable(trial_entry);
+        if (trial_entry.constraint_violation <
+                Scalar(0.9) * initial_entry.constraint_violation &&
+            filter.is_acceptable(trial_entry)) {
+          return ControlFlow::BREAK;
+        } else {
+          return ControlFlow::CONTINUE;
+        }
       });
       auto status = feasibility_restoration<Scalar>(matrices, callbacks,
                                                     options, x, y, iterations);
@@ -624,7 +633,7 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
 
 extern template SLEIPNIR_DLLEXPORT ExitStatus
 sqp(const SQPMatrixCallbacks<double>& matrix_callbacks,
-    std::span<std::function<bool(const IterationInfo<double>& info)>>
+    std::span<std::function<ControlFlow(const IterationInfo<double>& info)>>
         iteration_callbacks,
     const Options<double>& options, Eigen::VectorX<double>& x);
 

{sleipnirgroup_jormungandr-0.6.7.dev132 → sleipnirgroup_jormungandr-0.6.7.dev134}/include/sleipnir/optimization/solver/util/feasibility_restoration.hpp

@@ -13,6 +13,7 @@
 #include <Eigen/SparseCore>
 #include <gch/small_vector.hpp>
 
+#include "sleipnir/optimization/solver/control_flow.hpp"
 #include "sleipnir/optimization/solver/exit_status.hpp"
 #include "sleipnir/optimization/solver/ipm_matrix_callbacks.hpp"
 #include "sleipnir/optimization/solver/iteration_info.hpp"
@@ -25,16 +26,17 @@
 namespace slp {
 
 template <typename Scalar>
-ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
-               std::span<std::function<bool(const IterationInfo<Scalar>& info)>>
-                   iteration_callbacks,
-               const Options<Scalar>& options, bool in_feasibility_restoration,
+ExitStatus ipm(
+    const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
+    std::span<std::function<ControlFlow(const IterationInfo<Scalar>& info)>>
+        iteration_callbacks,
+    const Options<Scalar>& options, bool in_feasibility_restoration,
 #ifdef SLEIPNIR_ENABLE_BOUND_PROJECTION
-               const Eigen::ArrayX<bool>& bound_constraint_mask,
+    const Eigen::ArrayX<bool>& bound_constraint_mask,
 #endif
-               Eigen::VectorX<Scalar>& x, Eigen::VectorX<Scalar>& s,
-               Eigen::VectorX<Scalar>& y, Eigen::VectorX<Scalar>& z, Scalar& μ,
-               int& iterations);
+    Eigen::VectorX<Scalar>& x, Eigen::VectorX<Scalar>& s,
+    Eigen::VectorX<Scalar>& y, Eigen::VectorX<Scalar>& z, Scalar& μ,
+    int& iterations);
 
 /// Computes initial values for p and n in feasibility restoration.
 ///
@@ -113,7 +115,7 @@ std::tuple<Eigen::VectorX<Scalar>, Eigen::VectorX<Scalar>> compute_p_n(
 template <typename Scalar>
 ExitStatus feasibility_restoration(
     const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
-    std::span<std::function<bool(const IterationInfo<Scalar>& info)>>
+    std::span<std::function<ControlFlow(const IterationInfo<Scalar>& info)>>
         iteration_callbacks,
     const Options<Scalar>& options, Eigen::VectorX<Scalar>& x,
     Eigen::VectorX<Scalar>& y, int& iterations) {
@@ -371,7 +373,7 @@ ExitStatus feasibility_restoration(
 template <typename Scalar>
 ExitStatus feasibility_restoration(
     const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
-    std::span<std::function<bool(const IterationInfo<Scalar>& info)>>
+    std::span<std::function<ControlFlow(const IterationInfo<Scalar>& info)>>
         iteration_callbacks,
     const Options<Scalar>& options,
 #ifdef SLEIPNIR_ENABLE_BOUND_PROJECTION

{sleipnirgroup_jormungandr-0.6.7.dev132 → sleipnirgroup_jormungandr-0.6.7.dev134}/python/cpp/docstrings.hpp

@@ -798,12 +798,11 @@ constexpr char mkd_doc_slp_Problem_add_callback_2[] =
 R"doc(Adds a callback to be called at the beginning of each solver
 iteration.
 
-The callback for this overload should return bool.
+The callback for this overload should return ControlFlow.
 
 Args:
-    callback: The callback. Returning true from the callback causes
-              the solver to exit early with the solution it has so
-              far.
+    callback: The callback. Returning ControlFlow::BREAK from the
+              callback stops solving and returns the solution so far.
 
 )doc";
 
@@ -816,9 +815,8 @@ register callbacks that shouldn't be removed by clear_callbacks().
 Persistent callbacks run after non-persistent callbacks.
 
 Args:
-    callback: The callback. Returning true from the callback causes
-              the solver to exit early with the solution it has so
-              far.
+    callback: The callback. Returning ControlFlow::BREAK from the
+              callback stops solving and returns the solution so far.
 
 )doc";
 

{sleipnirgroup_jormungandr-0.6.7.dev132 → sleipnirgroup_jormungandr-0.6.7.dev134}/python/cpp/optimization/bind_problem.cpp

@@ -127,11 +127,11 @@ void bind_problem(nb::class_<Problem<double>>& cls) {
         new (self) Problem<double>();
 
         // Make Python signals (e.g., SIGINT from Ctrl-C) abort the solve
-        self->add_persistent_callback([](const IterationInfo<double>&) -> bool {
+        self->add_persistent_callback([](const IterationInfo<double>&) {
           if (PyErr_CheckSignals() != 0) {
             throw nb::python_error();
           }
-          return false;
+          return ControlFlow::CONTINUE;
         });
       },
       DOC(slp, Problem, Problem));
@@ -206,10 +206,28 @@ void bind_problem(nb::class_<Problem<double>>& cls) {
   cls.def(
       "add_callback",
       [](Problem<double>& self,
-         std::function<bool(const IterationInfo<double>& info)> callback) {
-        self.add_callback(std::move(callback));
+         std::function<void(const IterationInfo<double>& info)> callback) {
+        self.add_callback([callback = std::move(callback)](
+                              const IterationInfo<double>& info) {
+          try {
+            callback(info);
+          } catch (nb::python_error& e) {
+            if (e.matches(PyExc_StopIteration)) {
+              return ControlFlow::BREAK;
+            }
+            throw;
+          }
+          return ControlFlow::CONTINUE;
+        });
       },
-      "callback"_a, DOC(slp, Problem, add_callback, 2));
+      "callback"_a,
+      R"doc(Adds a callback to be called at the beginning of each solver
+iteration.
+
+Args:
+    callback: The callback. Raising StopIteration from the callback stops
+              solving and returns the solution so far.
+)doc");
   cls.def("clear_callbacks", &Problem<double>::clear_callbacks,
           DOC(slp, Problem, clear_callbacks));
 }

{sleipnirgroup_jormungandr-0.6.7.dev132 → sleipnirgroup_jormungandr-0.6.7.dev134}/python/src/sleipnir/__init__.py

@@ -2,4 +2,4 @@
 
 from ._sleipnir import *
 
-__version__ = "0.6.7.dev132"
+__version__ = "0.6.7.dev134"

{sleipnirgroup_jormungandr-0.6.7.dev132 → sleipnirgroup_jormungandr-0.6.7.dev134}/python/test/optimization/problem_spy_test.py

@@ -57,10 +57,9 @@ def test_problem_spy() -> None:
     global iterations
     iterations = 0
 
-    def callback(info: IterationInfo) -> bool:
+    def callback(info: IterationInfo) -> None:
         global iterations
         iterations += 1
-        return False
 
     problem.add_callback(callback)
 

{sleipnirgroup_jormungandr-0.6.7.dev132 → sleipnirgroup_jormungandr-0.6.7.dev134}/python/test/optimization/solver/exit_status_test.py

@@ -2,7 +2,7 @@
 
 import pytest
 from sleipnir.autodiff import ExpressionType, sqrt
-from sleipnir.optimization import ExitStatus, Problem
+from sleipnir.optimization import ExitStatus, IterationInfo, Problem
 from tolerance import solution_tolerance
 
 
@@ -11,16 +11,19 @@ def test_callback_requested_stop() -> None:
     x = problem.decision_variable()
     problem.minimize(x * x)
 
-    problem.add_callback(lambda info: False)
+    def stop(info: IterationInfo) -> None:
+        raise StopIteration
+
+    problem.add_callback(lambda info: None)
     x.set_value(1)
     assert problem.solve(diagnostics=True) == ExitStatus.SUCCESS
 
-    problem.add_callback(lambda info: True)
+    problem.add_callback(stop)
     x.set_value(1)
     assert problem.solve(diagnostics=True) == ExitStatus.CALLBACK_REQUESTED_STOP
 
     problem.clear_callbacks()
-    problem.add_callback(lambda info: False)
+    problem.add_callback(lambda info: None)
     x.set_value(1)
     assert problem.solve(diagnostics=True) == ExitStatus.SUCCESS
 

{sleipnirgroup_jormungandr-0.6.7.dev132 → sleipnirgroup_jormungandr-0.6.7.dev134}/src/optimization/solver/ipm.cpp

@@ -6,7 +6,7 @@
 
 template SLEIPNIR_DLLEXPORT slp::ExitStatus slp::ipm(
     const IPMMatrixCallbacks<double>& matrix_callbacks,
-    std::span<std::function<bool(const IterationInfo<double>& info)>>
+    std::span<std::function<ControlFlow(const IterationInfo<double>& info)>>
         iteration_callbacks,
     const Options<double>& options,
 #ifdef SLEIPNIR_ENABLE_BOUND_PROJECTION

{sleipnirgroup_jormungandr-0.6.7.dev132 → sleipnirgroup_jormungandr-0.6.7.dev134}/src/optimization/solver/newton.cpp

@@ -6,6 +6,6 @@
 
 template SLEIPNIR_DLLEXPORT slp::ExitStatus slp::newton(
     const NewtonMatrixCallbacks<double>& matrix_callbacks,
-    std::span<std::function<bool(const IterationInfo<double>& info)>>
+    std::span<std::function<ControlFlow(const IterationInfo<double>& info)>>
         iteration_callbacks,
     const Options<double>& options, Eigen::VectorX<double>& x);

{sleipnirgroup_jormungandr-0.6.7.dev132 → sleipnirgroup_jormungandr-0.6.7.dev134}/src/optimization/solver/sqp.cpp

@@ -6,6 +6,6 @@
 
 template SLEIPNIR_DLLEXPORT slp::ExitStatus slp::sqp(
     const SQPMatrixCallbacks<double>& matrix_callbacks,
-    std::span<std::function<bool(const IterationInfo<double>& info)>>
+    std::span<std::function<ControlFlow(const IterationInfo<double>& info)>>
         iteration_callbacks,
     const slp::Options<double>& options, Eigen::VectorX<double>& x);