sleipnirgroup-jormungandr 0.6.7.dev42__tar.gz → 0.6.7.dev45__tar.gz

{sleipnirgroup_jormungandr-0.6.7.dev42 → sleipnirgroup_jormungandr-0.6.7.dev45}/PKG-INFO

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

{sleipnirgroup_jormungandr-0.6.7.dev42 → sleipnirgroup_jormungandr-0.6.7.dev45}/include/sleipnir/autodiff/expression.hpp

@@ -772,8 +772,7 @@ constexpr void dec_ref_count(Expression<Scalar>* expr) {
       // refcounts, which was already done above.
       if constexpr (USE_POOL_ALLOCATOR) {
         auto alloc = global_pool_allocator<Expression<Scalar>>();
-        std::allocator_traits<decltype(alloc)>::deallocate(
-            alloc, elem, sizeof(Expression<Scalar>));
+        std::allocator_traits<decltype(alloc)>::deallocate(alloc, elem, 1);
       } else {
         operator delete(elem);
       }

{sleipnirgroup_jormungandr-0.6.7.dev42 → sleipnirgroup_jormungandr-0.6.7.dev45}/include/sleipnir/optimization/solver/ipm.hpp

@@ -777,30 +777,30 @@ ExitStatus ipm(const IPMMatrixCallbacks<Scalar>& matrix_callbacks,
       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
-      // barrier term Hessian μSₖ₊₁⁻².
-      //
-      //   Σₖ₊₁ = μSₖ₊₁⁻²
-      //   Sₖ₊₁⁻¹Zₖ₊₁ = μSₖ₊₁⁻²
-      //   Zₖ₊₁ = μSₖ₊₁⁻¹
-      //
-      // We ensure this by resetting
-      //
-      //   zₖ₊₁ = clamp(zₖ₊₁, 1/κ_Σ μ/sₖ₊₁, κ_Σ μ/sₖ₊₁)
-      //
-      // for some fixed κ_Σ ≥ 1 after each step. See equation (16) of [2].
-      for (int row = 0; row < z.rows(); ++row) {
-        constexpr Scalar κ_Σ(1e10);
-        z[row] =
-            std::clamp(z[row], Scalar(1) / κ_Σ * μ / s[row], κ_Σ * μ / s[row]);
-      }
-
       f = trial_f;
       c_e = trial_c_e;
       c_i = trial_c_i;
     }
 
+    // A requirement for the convergence proof is that the primal-dual barrier
+    // term Hessian Σₖ₊₁ does not deviate arbitrarily much from the primal
+    // barrier term Hessian μSₖ₊₁⁻².
+    //
+    //   Σₖ₊₁ = μSₖ₊₁⁻²
+    //   Sₖ₊₁⁻¹Zₖ₊₁ = μSₖ₊₁⁻²
+    //   Zₖ₊₁ = μSₖ₊₁⁻¹
+    //
+    // We ensure this by resetting
+    //
+    //   zₖ₊₁ = clamp(zₖ₊₁, 1/κ_Σ μ/sₖ₊₁, κ_Σ μ/sₖ₊₁)
+    //
+    // for some fixed κ_Σ ≥ 1 after each step. See equation (16) of [2].
+    for (int row = 0; row < z.rows(); ++row) {
+      constexpr Scalar κ_Σ(1e10);
+      z[row] =
+          std::clamp(z[row], Scalar(1) / κ_Σ * μ / s[row], κ_Σ * μ / s[row]);
+    }
+
     // Update autodiff for Jacobians and Hessian
     A_e = matrices.A_e(x);
     A_i = matrices.A_i(x);

{sleipnirgroup_jormungandr-0.6.7.dev42 → sleipnirgroup_jormungandr-0.6.7.dev45}/include/sleipnir/optimization/solver/util/feasibility_restoration.hpp

@@ -19,7 +19,6 @@
 #include "sleipnir/optimization/solver/options.hpp"
 #include "sleipnir/optimization/solver/sqp_matrix_callbacks.hpp"
 #include "sleipnir/optimization/solver/util/append_as_triplets.hpp"
-#include "sleipnir/optimization/solver/util/lagrange_multiplier_estimate.hpp"
 #include "sleipnir/optimization/solver/util/problem_scaling.hpp"
 #include "sleipnir/util/print_diagnostics.hpp"
 
@@ -317,7 +316,9 @@ ExitStatus feasibility_restoration(
     auto g = matrices.g(x);
     auto A_e = matrices.A_e(x);
 
-    y = lagrange_multiplier_estimate(g, A_e);
+    // Reset the equality constraint duals since feasibility restoration didn't
+    // account for the cost function
+    y.setZero();
 
     return ExitStatus::SUCCESS;
   } else if (status == ExitStatus::SUCCESS) {
@@ -649,8 +650,8 @@ ExitStatus feasibility_restoration(
     const DenseVector c_i = matrices.c_i(x);
     s = (c_i.array() >= Scalar(1e-2)).select(c_i, Scalar(1));
 
-    // Reset the equality constraint duals since the restoration phase didn't
-    // take the cost function into account
+    // Reset the equality constraint duals since feasibility restoration didn't
+    // account for the cost function
     y.setZero();
 
     // Update the inequality constraint duals with a Newton step for

{sleipnirgroup_jormungandr-0.6.7.dev42 → sleipnirgroup_jormungandr-0.6.7.dev45}/include/sleipnir/util/intrusive_shared_ptr.hpp

@@ -272,7 +272,7 @@ IntrusiveSharedPtr<T> make_intrusive_shared(Args&&... args) {
 /// @param args Constructor arguments for T.
 template <typename T, typename Alloc, typename... Args>
 IntrusiveSharedPtr<T> allocate_intrusive_shared(Alloc alloc, Args&&... args) {
-  auto ptr = std::allocator_traits<Alloc>::allocate(alloc, sizeof(T));
+  auto ptr = std::allocator_traits<Alloc>::allocate(alloc, 1);
   std::allocator_traits<Alloc>::construct(alloc, ptr,
                                           std::forward<Args>(args)...);
   return IntrusiveSharedPtr<T>{ptr};

{sleipnirgroup_jormungandr-0.6.7.dev42 → sleipnirgroup_jormungandr-0.6.7.dev45}/include/sleipnir/util/pool.hpp

@@ -199,19 +199,20 @@ class PoolAllocator {
 
   /// Returns a block of memory from the pool.
   ///
-  /// @param n Number of bytes in the block.
+  /// @param n Number of objects in the block.
   /// @return A block of memory from the pool.
   [[nodiscard]]
   constexpr T* allocate(size_t n) {
-    return static_cast<T*>(m_memory_resource->allocate(n, alignof(T)));
+    return static_cast<T*>(
+        m_memory_resource->allocate(n * sizeof(T), alignof(T)));
   }
 
   /// Gives a block of memory back to the pool.
   ///
   /// @param p A pointer to the block of memory.
-  /// @param n Number of bytes in the block.
+  /// @param n Number of objects in the block.
   constexpr void deallocate(T* p, size_t n) {
-    m_memory_resource->deallocate(p, n, alignof(T));
+    m_memory_resource->deallocate(p, n * sizeof(T), alignof(T));
   }
 
  private:

{sleipnirgroup_jormungandr-0.6.7.dev42 → sleipnirgroup_jormungandr-0.6.7.dev45}/python/src/sleipnir/__init__.py

@@ -2,4 +2,4 @@
 
 from ._sleipnir import *
 
-__version__ = "0.6.7.dev42"
+__version__ = "0.6.7.dev45"

sleipnirgroup_jormungandr-0.6.7.dev42/include/sleipnir/optimization/solver/util/lagrange_multiplier_estimate.hpp

@@ -1,30 +0,0 @@
-// Copyright (c) Sleipnir contributors
-
-#pragma once
-
-#include <Eigen/Core>
-#include <Eigen/SparseCholesky>
-#include <Eigen/SparseCore>
-
-namespace slp {
-
-/// Estimates Lagrange multipliers for SQP.
-///
-/// @tparam Scalar Scalar type.
-/// @param g Cost function gradient ∇f.
-/// @param A_e Equality constraint Jacobian Aₑ(x).
-template <typename Scalar>
-Eigen::Vector<Scalar, Eigen::Dynamic> lagrange_multiplier_estimate(
-    const Eigen::SparseVector<Scalar>& g,
-    const Eigen::SparseMatrix<Scalar>& A_e) {
-  // Lagrange multiplier estimates
-  //
-  //   ∇f − Aₑᵀy = 0
-  //   Aₑᵀy = ∇f
-  //   y = (AₑAₑᵀ)⁻¹Aₑ∇f
-  return Eigen::SimplicialLDLT<Eigen::SparseMatrix<Scalar>>{A_e *
-                                                            A_e.transpose()}
-      .solve(A_e * g);
-}
-
-}  // namespace slp