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

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

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

{sleipnirgroup_jormungandr-0.6.7.dev2 → sleipnirgroup_jormungandr-0.6.7.dev4}/cmake/Pybind11Mkdoc.cmake

@@ -5,16 +5,16 @@ function(pybind11_mkdoc target headers)
     get_target_property(target_flags ${target} INCLUDE_DIRECTORIES)
     list(TRANSFORM target_flags PREPEND "-I")
 
-    # Get default clang version
-    execute_process(
-        COMMAND clang++ --version
-        OUTPUT_VARIABLE clang_version
-        COMMAND_ERROR_IS_FATAL ANY
-    )
-    string(REGEX MATCH "[0-9]+" clang_version ${clang_version})
-
-    # LLVM environment variables
     if(UNIX AND NOT APPLE)
+        # Get default clang version
+        execute_process(
+            COMMAND clang++ --version
+            OUTPUT_VARIABLE clang_version
+            COMMAND_ERROR_IS_FATAL ANY
+        )
+        string(REGEX MATCH "[0-9]+" clang_version ${clang_version})
+
+        # LLVM environment variables
         if(EXISTS /usr/lib/libclang.so)
             set(env_vars
                 LLVM_DIR_PATH=/usr/lib
@@ -26,10 +26,8 @@ function(pybind11_mkdoc target headers)
                 LIBCLANG_PATH=/usr/lib/llvm-${clang_version}/lib/libclang.so
             )
         endif()
-    endif()
 
-    # Clang compiler flags
-    if(UNIX AND NOT APPLE)
+        # Clang compiler flags
         set(clang_flags -I/usr/lib/clang/${clang_version}/include)
     endif()
 

{sleipnirgroup_jormungandr-0.6.7.dev2 → sleipnirgroup_jormungandr-0.6.7.dev4}/include/sleipnir/optimization/solver/ipm.hpp

@@ -22,7 +22,7 @@
 #include "sleipnir/optimization/solver/util/filter.hpp"
 #include "sleipnir/optimization/solver/util/fraction_to_the_boundary_rule.hpp"
 #include "sleipnir/optimization/solver/util/kkt_error.hpp"
-#include "sleipnir/optimization/solver/util/regularized_ldlt.hpp"
+#include "sleipnir/optimization/solver/util/kkt_solver.hpp"
 #include "sleipnir/util/assert.hpp"
 #include "sleipnir/util/print_diagnostics.hpp"
 #include "sleipnir/util/profiler.hpp"
@@ -333,7 +333,7 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
 
   const int lhs_rows =
       matrices.num_decision_variables + matrices.num_equality_constraints;
-  RegularizedLDLT<Scalar> solver{
+  KKTSolver<Scalar> solver{
       // Use sparse solver if lower triangle fills < 25% of system
       H.nonZeros() +
               (A_i.transpose() * A_i)

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

@@ -18,7 +18,7 @@
 #include "sleipnir/optimization/solver/util/all_finite.hpp"
 #include "sleipnir/optimization/solver/util/filter.hpp"
 #include "sleipnir/optimization/solver/util/kkt_error.hpp"
-#include "sleipnir/optimization/solver/util/regularized_ldlt.hpp"
+#include "sleipnir/optimization/solver/util/kkt_solver.hpp"
 #include "sleipnir/util/assert.hpp"
 #include "sleipnir/util/print_diagnostics.hpp"
 #include "sleipnir/util/profiler.hpp"
@@ -131,7 +131,7 @@ ExitStatus newton(
 
   Filter<Scalar> filter;
 
-  RegularizedLDLT<Scalar> solver{
+  KKTSolver<Scalar> solver{
       // Use sparse solver if lower triangle fills < 25% of system
       H.nonZeros() < 0.25 * H.size(), matrices.num_decision_variables, 0};
 

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

@@ -20,7 +20,7 @@
 #include "sleipnir/optimization/solver/util/feasibility_restoration.hpp"
 #include "sleipnir/optimization/solver/util/filter.hpp"
 #include "sleipnir/optimization/solver/util/kkt_error.hpp"
-#include "sleipnir/optimization/solver/util/regularized_ldlt.hpp"
+#include "sleipnir/optimization/solver/util/kkt_solver.hpp"
 #include "sleipnir/util/assert.hpp"
 #include "sleipnir/util/print_diagnostics.hpp"
 #include "sleipnir/util/profiler.hpp"
@@ -225,7 +225,7 @@ ExitStatus sqp(const SQPMatrixCallbacks<Scalar>& matrix_callbacks,
 
   const int lhs_rows =
       matrices.num_decision_variables + matrices.num_equality_constraints;
-  RegularizedLDLT<Scalar> solver{
+  KKTSolver<Scalar> solver{
       // Use sparse solver if lower triangle fills < 25% of system
       H.nonZeros() + A_e.nonZeros() < 0.25 * lhs_rows * lhs_rows,
       matrices.num_decision_variables, matrices.num_equality_constraints};

sleipnirgroup_jormungandr-0.6.7.dev2/include/sleipnir/optimization/solver/util/dense_regularized_ldlt.hpp → sleipnirgroup_jormungandr-0.6.7.dev4/include/sleipnir/optimization/solver/util/dense_kkt_solver.hpp

@@ -12,37 +12,38 @@
 
 namespace slp {
 
-/// Solves dense systems of linear equations using a regularized LDLT
-/// factorization.
+/// Solves a dense KKT system.
+///
+/// Applies regularization so the solution is a descent direction.
 ///
 /// @tparam Scalar Scalar type.
 template <typename Scalar>
-class DenseRegularizedLDLT {
+class DenseKKTSolver {
  public:
   /// Type alias for dense matrix.
   using DenseMatrix = Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic>;
   /// Type alias for dense vector.
   using DenseVector = Eigen::Vector<Scalar, Eigen::Dynamic>;
 
-  /// Constructs a DenseRegularizedLDLT instance.
+  /// Constructs a DenseKKTSolver instance.
   ///
   /// @param num_decision_variables The number of decision variables in the
   ///     system.
   /// @param num_equality_constraints The number of equality constraints in the
   ///     system.
-  DenseRegularizedLDLT(int num_decision_variables, int num_equality_constraints)
+  DenseKKTSolver(int num_decision_variables, int num_equality_constraints)
       : m_num_decision_variables{num_decision_variables},
         m_num_equality_constraints{num_equality_constraints} {}
 
-  /// Constructs a DenseRegularizedLDLT instance.
+  /// Constructs a DenseKKTSolver instance.
   ///
   /// @param num_decision_variables The number of decision variables in the
   ///     system.
   /// @param num_equality_constraints The number of equality constraints in the
   ///     system.
   /// @param γ_min The minimum constraint regularization.
-  DenseRegularizedLDLT(int num_decision_variables, int num_equality_constraints,
-                       Scalar γ_min)
+  DenseKKTSolver(int num_decision_variables, int num_equality_constraints,
+                 Scalar γ_min)
       : m_num_decision_variables{num_decision_variables},
         m_num_equality_constraints{num_equality_constraints},
         m_γ_min{γ_min} {}
@@ -52,11 +53,11 @@ class DenseRegularizedLDLT {
   /// @return Whether previous computation was successful.
   Eigen::ComputationInfo info() const { return m_info; }
 
-  /// Computes the regularized LDLT factorization of a matrix.
+  /// Computes the factorization of the KKT matrix.
   ///
   /// @param lhs Left-hand side of the system.
   /// @return The factorization.
-  DenseRegularizedLDLT& compute(const DenseMatrix& lhs) {
+  DenseKKTSolver& compute(const DenseMatrix& lhs) {
     m_info = m_solver.compute(lhs).info();
 
     if (m_info == Eigen::Success) {
@@ -135,7 +136,7 @@ class DenseRegularizedLDLT {
     }
   }
 
-  /// Solves the system of equations using a regularized LDLT factorization.
+  /// Solves the system of equations.
   ///
   /// @param rhs Right-hand side of the system.
   /// @return The solution.
@@ -144,7 +145,7 @@ class DenseRegularizedLDLT {
     return m_solver.solve(rhs);
   }
 
-  /// Solves the system of equations using a regularized LDLT factorization.
+  /// Solves the system of equations.
   ///
   /// @param rhs Right-hand side of the system.
   /// @return The solution.

sleipnirgroup_jormungandr-0.6.7.dev2/include/sleipnir/optimization/solver/util/regularized_ldlt.hpp → sleipnirgroup_jormungandr-0.6.7.dev4/include/sleipnir/optimization/solver/util/kkt_solver.hpp

@@ -5,36 +5,38 @@
 #include <Eigen/Core>
 #include <Eigen/SparseCore>
 
-#include "sleipnir/optimization/solver/util/dense_regularized_ldlt.hpp"
-#include "sleipnir/optimization/solver/util/sparse_regularized_ldlt.hpp"
+#include "sleipnir/optimization/solver/util/dense_kkt_solver.hpp"
+#include "sleipnir/optimization/solver/util/sparse_kkt_solver.hpp"
 
 namespace slp {
 
-/// Solves systems of linear equations using a regularized LDLT factorization.
+/// Solves a KKT system.
+///
+/// Applies regularization so the solution is a descent direction.
 ///
 /// @tparam Scalar Scalar type.
 template <typename Scalar>
-class RegularizedLDLT {
+class KKTSolver {
  public:
   /// Type alias for dense vector.
   using DenseVector = Eigen::Vector<Scalar, Eigen::Dynamic>;
   /// Type alias for sparse matrix.
   using SparseMatrix = Eigen::SparseMatrix<Scalar>;
 
-  /// Constructs a RegularizedLDLT instance.
+  /// Constructs a KKTSolver instance.
   ///
   /// @param use_sparse_solver Whether to use sparse or dense solver.
   /// @param num_decision_variables The number of decision variables in the
   ///     system.
   /// @param num_equality_constraints The number of equality constraints in the
   ///     system.
-  RegularizedLDLT(bool use_sparse_solver, int num_decision_variables,
-                  int num_equality_constraints)
+  KKTSolver(bool use_sparse_solver, int num_decision_variables,
+            int num_equality_constraints)
       : m_use_sparse_solver{use_sparse_solver},
         m_sparse_solver{num_decision_variables, num_equality_constraints},
         m_dense_solver{num_decision_variables, num_equality_constraints} {}
 
-  /// Constructs a RegularizedLDLT instance.
+  /// Constructs a KKTSolver instance.
   ///
   /// @param use_sparse_solver Whether to use sparse or dense solver.
   /// @param num_decision_variables The number of decision variables in the
@@ -42,8 +44,8 @@ class RegularizedLDLT {
   /// @param num_equality_constraints The number of equality constraints in the
   ///     system.
   /// @param γ_min The minimum constraint regularization.
-  RegularizedLDLT(bool use_sparse_solver, int num_decision_variables,
-                  int num_equality_constraints, Scalar γ_min)
+  KKTSolver(bool use_sparse_solver, int num_decision_variables,
+            int num_equality_constraints, Scalar γ_min)
       : m_use_sparse_solver{use_sparse_solver},
         m_sparse_solver{num_decision_variables, num_equality_constraints,
                         γ_min},
@@ -61,7 +63,7 @@ class RegularizedLDLT {
     }
   }
 
-  /// Computes the regularized LDLT factorization of a matrix.
+  /// Computes the factorization of the KKT matrix.
   ///
   /// In sparse mode, the matrix's symbolic decomposition is reused in
   /// subsequent calls, so subsequent calls must be given a matrix with the same
@@ -69,7 +71,7 @@ class RegularizedLDLT {
   ///
   /// @param lhs Left-hand side of the system.
   /// @return The factorization.
-  RegularizedLDLT& compute(const SparseMatrix& lhs) {
+  KKTSolver& compute(const SparseMatrix& lhs) {
     if (m_use_sparse_solver) {
       m_sparse_solver.compute(lhs);
     } else {
@@ -79,7 +81,7 @@ class RegularizedLDLT {
     return *this;
   }
 
-  /// Solves the system of equations using a regularized LDLT factorization.
+  /// Solves the system of equations.
   ///
   /// @param rhs Right-hand side of the system.
   /// @return The solution.
@@ -92,7 +94,7 @@ class RegularizedLDLT {
     }
   }
 
-  /// Solves the system of equations using a regularized LDLT factorization.
+  /// Solves the system of equations.
   ///
   /// @param rhs Right-hand side of the system.
   /// @return The solution.
@@ -129,8 +131,8 @@ class RegularizedLDLT {
 
  private:
   bool m_use_sparse_solver;
-  SparseRegularizedLDLT<Scalar> m_sparse_solver;
-  DenseRegularizedLDLT<Scalar> m_dense_solver;
+  SparseKKTSolver<Scalar> m_sparse_solver;
+  DenseKKTSolver<Scalar> m_dense_solver;
 };
 
 }  // namespace slp

sleipnirgroup_jormungandr-0.6.7.dev2/include/sleipnir/optimization/solver/util/sparse_regularized_ldlt.hpp → sleipnirgroup_jormungandr-0.6.7.dev4/include/sleipnir/optimization/solver/util/sparse_kkt_solver.hpp

@@ -13,38 +13,38 @@
 
 namespace slp {
 
-/// Solves sparse systems of linear equations using a regularized LDLT
-/// factorization.
+/// Solves a sparse KKT system.
+///
+/// Applies regularization so the solution is a descent direction.
 ///
 /// @tparam Scalar Scalar type.
 template <typename Scalar>
-class SparseRegularizedLDLT {
+class SparseKKTSolver {
  public:
   /// Type alias for dense vector.
   using DenseVector = Eigen::Vector<Scalar, Eigen::Dynamic>;
   /// Type alias for sparse matrix.
   using SparseMatrix = Eigen::SparseMatrix<Scalar>;
 
-  /// Constructs a SparseRegularizedLDLT instance.
+  /// Constructs a SparseKKTSolver instance.
   ///
   /// @param num_decision_variables The number of decision variables in the
   ///     system.
   /// @param num_equality_constraints The number of equality constraints in the
   ///     system.
-  SparseRegularizedLDLT(int num_decision_variables,
-                        int num_equality_constraints)
+  SparseKKTSolver(int num_decision_variables, int num_equality_constraints)
       : m_num_decision_variables{num_decision_variables},
         m_num_equality_constraints{num_equality_constraints} {}
 
-  /// Constructs a SparseRegularizedLDLT instance.
+  /// Constructs a SparseKKTSolver instance.
   ///
   /// @param num_decision_variables The number of decision variables in the
   ///     system.
   /// @param num_equality_constraints The number of equality constraints in the
   ///     system.
   /// @param γ_min The minimum constraint regularization.
-  SparseRegularizedLDLT(int num_decision_variables,
-                        int num_equality_constraints, Scalar γ_min)
+  SparseKKTSolver(int num_decision_variables, int num_equality_constraints,
+                  Scalar γ_min)
       : m_num_decision_variables{num_decision_variables},
         m_num_equality_constraints{num_equality_constraints},
         m_γ_min{γ_min} {}
@@ -54,14 +54,14 @@ class SparseRegularizedLDLT {
   /// @return Whether previous computation was successful.
   Eigen::ComputationInfo info() const { return m_info; }
 
-  /// Computes the regularized LDLT factorization of a matrix.
+  /// Computes the factorization of the KKT matrix.
   ///
   /// The matrix's symbolic decomposition is reused in subsequent calls, so
   /// subsequent calls must be given a matrix with the same sparsity pattern.
   ///
   /// @param lhs Left-hand side of the system.
   /// @return The factorization.
-  SparseRegularizedLDLT& compute(const SparseMatrix& lhs) {
+  SparseKKTSolver& compute(const SparseMatrix& lhs) {
     // Regularization with zeros ensures the pattern analysis in the sparse
     // solver is reused by all factorizations
     SparseMatrix unregularized_lhs = lhs + regularization(Scalar(0), Scalar(0));
@@ -151,7 +151,7 @@ class SparseRegularizedLDLT {
     }
   }
 
-  /// Solves the system of equations using a regularized LDLT factorization.
+  /// Solves the system of equations.
   ///
   /// @param rhs Right-hand side of the system.
   /// @return The solution.
@@ -160,7 +160,7 @@ class SparseRegularizedLDLT {
     return m_solver.solve(rhs);
   }
 
-  /// Solves the system of equations using a regularized LDLT factorization.
+  /// Solves the system of equations.
   ///
   /// @param rhs Right-hand side of the system.
   /// @return The solution.

{sleipnirgroup_jormungandr-0.6.7.dev2 → sleipnirgroup_jormungandr-0.6.7.dev4}/pyproject.toml

@@ -13,8 +13,8 @@ license-files = ["LICENSE.txt"]
 
 [build-system]
 requires = [
-  "nanobind~=2.15.0",
-  "py-build-cmake~=0.5.0",
+  "nanobind~=3.0.1",
+  "py-build-cmake~=0.5.1",
   "pybind11-mkdoc~=3.0.0",
 ]
 build-backend = "py_build_cmake.build"

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

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