sleipnirgroup-jormungandr 0.6.5.dev22__tar.gz → 0.6.5.dev23__tar.gz

{sleipnirgroup_jormungandr-0.6.5.dev22 → sleipnirgroup_jormungandr-0.6.5.dev23}/PKG-INFO

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

{sleipnirgroup_jormungandr-0.6.5.dev22 → sleipnirgroup_jormungandr-0.6.5.dev23}/include/sleipnir/autodiff/variable_block.hpp

@@ -624,6 +624,13 @@ class VariableBlock : public SleipnirBase {
     return result;
   }
 
+  /// Returns the matrix exponential.
+  ///
+  /// @return The matrix exponential.
+  std::remove_cv_t<Mat> exp() const {
+    return std::remove_cv_t<Mat>{*this}.exp();
+  }
+
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 
   class iterator {

{sleipnirgroup_jormungandr-0.6.5.dev22 → sleipnirgroup_jormungandr-0.6.5.dev23}/include/sleipnir/autodiff/variable_matrix.hpp

@@ -3,6 +3,7 @@
 #pragma once
 
 #include <algorithm>
+#include <array>
 #include <concepts>
 #include <cstddef>
 #include <initializer_list>
@@ -12,6 +13,7 @@
 #include <vector>
 
 #include <Eigen/Core>
+#include <Eigen/LU>
 #include <Eigen/QR>
 #include <gch/small_vector.hpp>
 
@@ -1036,6 +1038,88 @@ class VariableMatrix : public SleipnirBase {
     return result;
   }
 
+  /// Returns the matrix exponential.
+  ///
+  /// @return The matrix exponential.
+  VariableMatrix<Scalar> exp() const {
+    slp_assert(rows() == cols());
+
+    // Coefficients for (13, 13) Padé approximant of exp(A) are from the
+    // following program:
+    //
+    // #!/usr/bin/env python
+    //
+    // import mpmath as mp
+    //
+    // # https://en.wikipedia.org/wiki/IEEE_754#Basic_and_interchange_formats
+    // mp.mp.prec = 113  # quad precision
+    //
+    // L = 13
+    // M = 13
+    // p, q = mp.pade(mp.taylor(mp.exp, 0, L + M), L, M)
+    //
+    // print("constexpr std::array p{")
+    // for k, p_k in enumerate(p):
+    //     print(f"Scalar({p_k}L){',' if k < len(p) - 1 else '};'}")
+    // print("constexpr std::array q{")
+    // for k, q_k in enumerate(q):
+    //     print(f"Scalar({q_k}L){',' if k < len(q) - 1 else '};'}")
+    constexpr size_t NUM_COEFFS = 14;
+    constexpr std::array p{Scalar(1.0L),
+                           Scalar(0.499999999999999999999987615564159L),
+                           Scalar(0.119999999999999999999993719796468L),
+                           Scalar(0.0183333333333333333333318078905823L),
+                           Scalar(0.00199275362318840579710121408775205L),
+                           Scalar(0.00016304347826086956521736560868541L),
+                           Scalar(1.03519668737060041407846479512981e-05L),
+                           Scalar(5.17598343685300207039205144279119e-07L),
+                           Scalar(2.04315135665250081725989398668247e-08L),
+                           Scalar(6.30602270571759511499920806570486e-10L),
+                           Scalar(1.48377004840414002705850442238441e-11L),
+                           Scalar(2.52915349159796595521307855480881e-13L),
+                           Scalar(2.81017054621996217245857568431558e-15L),
+                           Scalar(1.54404975067030888596595580141692e-17L)};
+    constexpr std::array q{Scalar(1.0L),
+                           Scalar(-0.500000000000000000000012384435841L),
+                           Scalar(0.120000000000000000000006104232309L),
+                           Scalar(-0.0183333333333333333333347707904729L),
+                           Scalar(0.00199275362318840579710166350137732L),
+                           Scalar(-0.000163043478260869565217413851346892L),
+                           Scalar(1.03519668737060041407885187519331e-05L),
+                           Scalar(-5.17598343685300207039443859549262e-07L),
+                           Scalar(2.04315135665250081726103781506842e-08L),
+                           Scalar(-6.30602270571759511500345035969254e-10L),
+                           Scalar(1.48377004840414002705969744674248e-11L),
+                           Scalar(-2.52915349159796595521550648156349e-13L),
+                           Scalar(2.81017054621996217246180850207342e-15L),
+                           Scalar(-1.54404975067030888596810607146175e-17L)};
+    static_assert(p.size() == NUM_COEFFS);
+    static_assert(q.size() == NUM_COEFFS);
+
+    //     13
+    // P = Σ pₖAᵏ
+    //    k=0
+    //
+    //     13
+    // Q = Σ qₖAᵏ
+    //    k=0
+    VariableMatrix<Scalar> P{
+        Eigen::Vector<Scalar, Eigen::Dynamic>::Constant(rows(), p[0])
+            .asDiagonal()};
+    VariableMatrix<Scalar> Q{
+        Eigen::Vector<Scalar, Eigen::Dynamic>::Constant(rows(), q[0])
+            .asDiagonal()};
+    auto A_pow = *this;
+    for (size_t k = 1; k < NUM_COEFFS; ++k) {
+      P += p[k] * A_pow;
+      Q += q[k] * A_pow;
+      A_pow *= *this;
+    }
+
+    // exp(A) ≈ P/Q
+    return VariableMatrix<Scalar>{Q.to_eigen().lu().solve(P.to_eigen())};
+  }
+
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 
   class iterator {

{sleipnirgroup_jormungandr-0.6.5.dev22 → sleipnirgroup_jormungandr-0.6.5.dev23}/python/cpp/autodiff/bind_variable_block.cpp

@@ -392,6 +392,8 @@ void bind_variable_block(
          const std::function<Variable<double>(const Variable<double>& x)>&
              unary_op) { return self.cwise_transform(unary_op); },
       "func"_a, DOC(slp, VariableBlock, cwise_transform));
+  cls.def("exp", &VariableBlock<VariableMatrix<double>>::exp,
+          DOC(slp, VariableBlock, exp));
 
   // Comparison operators
   for_each_type<nb::detail::self_t, double, int, Variable<double>>(

{sleipnirgroup_jormungandr-0.6.5.dev22 → sleipnirgroup_jormungandr-0.6.5.dev23}/python/cpp/autodiff/bind_variable_matrix.cpp

@@ -439,6 +439,7 @@ void bind_variable_matrix(nb::module_& autodiff,
          const std::function<Variable<double>(const Variable<double>& x)>&
              unary_op) { return self.cwise_transform(unary_op); },
       "func"_a, DOC(slp, VariableMatrix, cwise_transform));
+  cls.def("exp", &VariableMatrix<double>::exp, DOC(slp, VariableMatrix, exp));
   cls.def_static("identity", &VariableMatrix<double>::identity, "rows"_a,
                  DOC(slp, VariableMatrix, identity));
   cls.def_static("zero", &VariableMatrix<double>::zero, "rows"_a, "cols"_a,

{sleipnirgroup_jormungandr-0.6.5.dev22 → sleipnirgroup_jormungandr-0.6.5.dev23}/python/cpp/docstrings.hpp

@@ -1160,6 +1160,12 @@ R"doc(Returns end iterator.
 Returns:
     End iterator.)doc";
 
+static const char *__doc_slp_VariableBlock_exp =
+R"doc(Returns the matrix exponential.
+
+Returns:
+    The matrix exponential.)doc";
+
 static const char *__doc_slp_VariableBlock_iterator = R"doc()doc";
 
 static const char *__doc_slp_VariableBlock_iterator_iterator = R"doc()doc";
@@ -1812,6 +1818,12 @@ R"doc(Returns const end iterator.
 Returns:
     Const end iterator.)doc";
 
+static const char *__doc_slp_VariableMatrix_exp =
+R"doc(Returns the matrix exponential.
+
+Returns:
+    The matrix exponential.)doc";
+
 static const char *__doc_slp_VariableMatrix_identity =
 R"doc(Returns an identity variable matrix.
 

{sleipnirgroup_jormungandr-0.6.5.dev22 → sleipnirgroup_jormungandr-0.6.5.dev23}/python/src/sleipnir/__init__.py

@@ -2,4 +2,4 @@
 
 from ._sleipnir import *
 
-__version__ = "0.6.5.dev22"
+__version__ = "0.6.5.dev23"

{sleipnirgroup_jormungandr-0.6.5.dev22 → sleipnirgroup_jormungandr-0.6.5.dev23}/python/test/autodiff/variable_matrix_test.py

@@ -404,6 +404,45 @@ def test_cwise_reduce():
     assert (result.value() == np.array([[16.0, 27.0, 40.0], [55.0, 72.0, 91.0]])).all()
 
 
+def test_exp():
+    A1 = VariableMatrix([[4.0]])
+    np.testing.assert_allclose(A1.exp().value() @ (-A1).exp().value(), np.identity(1))
+    np.testing.assert_allclose(
+        A1[:, :].exp().value() @ (-A1[:, :]).exp().value(), np.identity(1)
+    )
+
+    A2 = VariableMatrix([[0.0, 1.0], [0.0, -0.5]])
+    np.testing.assert_allclose(
+        A2.exp().value() @ (-A2).exp().value(), np.identity(2), atol=1e-15
+    )
+    np.testing.assert_allclose(
+        A2[:, :].exp().value() @ (-A2[:, :]).exp().value(), np.identity(2), atol=1e-15
+    )
+
+    A3 = VariableMatrix([[0.0, 1.0], [0.0, 10.0]])
+    np.testing.assert_allclose(
+        A3.exp().value() @ (-A3).exp().value(), np.identity(2), atol=1e-15
+    )
+    np.testing.assert_allclose(
+        A3[:, :].exp().value() @ (-A3[:, :]).exp().value(), np.identity(2), atol=1e-15
+    )
+    A4 = VariableMatrix([[1.0, 10.0], [0.0, 0.0]])
+    np.testing.assert_allclose(
+        A4.exp().value() @ (-A4).exp().value(), np.identity(2), atol=1e-15
+    )
+    np.testing.assert_allclose(
+        A4[:, :].exp().value() @ (-A4[:, :]).exp().value(), np.identity(2), atol=1e-15
+    )
+
+    A5 = VariableMatrix([[2.0, 3.0], [4.0, 5.0]])
+    np.testing.assert_allclose(
+        A5.exp().value() @ (-A5).exp().value(), np.identity(2), atol=1e-12
+    )
+    np.testing.assert_allclose(
+        A5[:, :].exp().value() @ (-A5[:, :]).exp().value(), np.identity(2), atol=1e-12
+    )
+
+
 def test_block_free_function():
     A = VariableMatrix([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
     B = VariableMatrix([[7.0], [8.0]])