sleipnirgroup-jormungandr 0.6.5.dev8__tar.gz → 0.6.5.dev9__tar.gz

{sleipnirgroup_jormungandr-0.6.5.dev8 → sleipnirgroup_jormungandr-0.6.5.dev9}/PKG-INFO

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

{sleipnirgroup_jormungandr-0.6.5.dev8 → sleipnirgroup_jormungandr-0.6.5.dev9}/include/sleipnir/autodiff/expression.hpp

@@ -428,6 +428,8 @@ ExpressionPtr<Scalar> cbrt(const ExpressionPtr<Scalar>& x);
 template <typename Scalar>
 ExpressionPtr<Scalar> exp(const ExpressionPtr<Scalar>& x);
 template <typename Scalar>
+ExpressionPtr<Scalar> sign(const ExpressionPtr<Scalar>& x);
+template <typename Scalar>
 ExpressionPtr<Scalar> sin(const ExpressionPtr<Scalar>& x);
 template <typename Scalar>
 ExpressionPtr<Scalar> sinh(const ExpressionPtr<Scalar>& x);
@@ -797,13 +799,7 @@ struct AbsExpression final : Expression<Scalar> {
   ExpressionPtr<Scalar> grad_expr_l(
       const ExpressionPtr<Scalar>& x,
       const ExpressionPtr<Scalar>&) const override {
-    if (x->val < Scalar(0)) {
-      return -this->adjoint_expr;
-    } else if (x->val > Scalar(0)) {
-      return this->adjoint_expr;
-    } else {
-      return constant_ptr(Scalar(0));
-    }
+    return this->adjoint_expr * sign(x);
   }
 };
 
@@ -1356,6 +1352,72 @@ ExpressionPtr<Scalar> hypot(const ExpressionPtr<Scalar>& x,
   return make_expression_ptr<HypotExpression<Scalar>>(x, y);
 }
 
+/// Derived expression type for is_nonnegative().
+///
+/// @tparam Scalar Scalar type.
+template <typename Scalar>
+struct IsNonnegativeExpression final : Expression<Scalar> {
+  /// Constructs an unary expression (an operator with one argument).
+  ///
+  /// @param x Unary operator's operand.
+  explicit constexpr IsNonnegativeExpression(ExpressionPtr<Scalar> x)
+      : Expression<Scalar>{std::move(x)} {}
+
+  Scalar value(Scalar x, Scalar) const override {
+    return x >= Scalar(0) ? Scalar(1) : Scalar(0);
+  }
+
+  ExpressionType type() const override { return ExpressionType::NONLINEAR; }
+
+  std::string_view name() const override { return "is nonnegative"; }
+};
+
+/// Returns one if x is nonnegative and zero otherwise.
+///
+/// @tparam Scalar Scalar type.
+/// @param x The argument.
+template <typename Scalar>
+ExpressionPtr<Scalar> is_nonnegative(const ExpressionPtr<Scalar>& x) {
+  if (x->type() == ExpressionType::CONSTANT) {
+    return constant_ptr(x->val >= Scalar(0) ? Scalar(1) : Scalar(0));
+  }
+
+  return make_expression_ptr<IsNonnegativeExpression<Scalar>>(x);
+}
+
+/// Derived expression type for is_positive().
+///
+/// @tparam Scalar Scalar type.
+template <typename Scalar>
+struct IsPositiveExpression final : Expression<Scalar> {
+  /// Constructs an unary expression (an operator with one argument).
+  ///
+  /// @param x Unary operator's operand.
+  explicit constexpr IsPositiveExpression(ExpressionPtr<Scalar> x)
+      : Expression<Scalar>{std::move(x)} {}
+
+  Scalar value(Scalar x, Scalar) const override {
+    return x > Scalar(0) ? Scalar(1) : Scalar(0);
+  }
+
+  ExpressionType type() const override { return ExpressionType::NONLINEAR; }
+
+  std::string_view name() const override { return "is positive"; }
+};
+
+/// Returns one if x is positive and zero otherwise.
+///
+/// @tparam Scalar Scalar type.
+/// @param x The argument.
+template <typename Scalar>
+ExpressionPtr<Scalar> is_positive(const ExpressionPtr<Scalar>& x) {
+  if (x->type() == ExpressionType::CONSTANT) {
+    return constant_ptr(x->val > Scalar(0) ? Scalar(1) : Scalar(0));
+  }
+
+  return make_expression_ptr<IsPositiveExpression<Scalar>>(x);
+}
+
 /// Derived expression type for log().
 ///
 /// @tparam Scalar Scalar type.
@@ -1496,13 +1558,19 @@ struct MaxExpression final : Expression<Scalar> {
   ExpressionPtr<Scalar> grad_expr_l(
       const ExpressionPtr<Scalar>& a,
       const ExpressionPtr<Scalar>& b) const override {
-    return a->val >= b->val ? this->adjoint_expr : constant_ptr(Scalar(0));
+    // adjoint * (a >= b)
+    // adjoint * (a - b >= 0)
+    return this->adjoint_expr * is_nonnegative(a - b);
   }
 
   ExpressionPtr<Scalar> grad_expr_r(
       const ExpressionPtr<Scalar>& a,
       const ExpressionPtr<Scalar>& b) const override {
-    return a->val >= b->val ? constant_ptr(Scalar(0)) : this->adjoint_expr;
+    // adjoint * !(a >= b)
+    // adjoint * (a < b)
+    // adjoint * (b > a)
+    // adjoint * (b - a > 0)
+    return this->adjoint_expr * is_positive(b - a);
   }
 };
 
@@ -1560,13 +1628,19 @@ struct MinExpression final : Expression<Scalar> {
   ExpressionPtr<Scalar> grad_expr_l(
       const ExpressionPtr<Scalar>& a,
       const ExpressionPtr<Scalar>& b) const override {
-    return a->val <= b->val ? this->adjoint_expr : constant_ptr(Scalar(0));
+    // adjoint * (a <= b)
+    // adjoint * (b >= a)
+    // adjoint * (b - a >= 0)
+    return this->adjoint_expr * is_nonnegative(b - a);
   }
 
   ExpressionPtr<Scalar> grad_expr_r(
       const ExpressionPtr<Scalar>& a,
       const ExpressionPtr<Scalar>& b) const override {
-    return a->val <= b->val ? constant_ptr(Scalar(0)) : this->adjoint_expr;
+    // adjoint * !(a <= b)
+    // adjoint * (a > b)
+    // adjoint * (a - b > 0)
+    return this->adjoint_expr * is_positive(a - b);
   }
 };
 
@@ -1624,9 +1698,7 @@ struct PowExpression final : Expression<Scalar> {
     using std::log;
     using std::pow;
 
-    // Since x log(x) -> 0 as x -> 0
-    return base == Scalar(0) ? Scalar(0)
-                             : this->adjoint * pow(base, power) * log(base);
+    return this->adjoint * pow(base, power) * log(base);
   }
 
   ExpressionPtr<Scalar> grad_expr_l(
@@ -1639,10 +1711,7 @@ struct PowExpression final : Expression<Scalar> {
   ExpressionPtr<Scalar> grad_expr_r(
       const ExpressionPtr<Scalar>& base,
       const ExpressionPtr<Scalar>& power) const override {
-    // Since x log(x) -> 0 as x -> 0
-    return base->val == Scalar(0)
-               ? base  // Return zero
-               : this->adjoint_expr * pow(base, power) * log(base);
+    return this->adjoint_expr * pow(base, power) * log(base);
   }
 };
 

{sleipnirgroup_jormungandr-0.6.5.dev8 → sleipnirgroup_jormungandr-0.6.5.dev9}/python/src/sleipnir/__init__.py

@@ -2,4 +2,4 @@
 
 from ._sleipnir import *
 
-__version__ = "0.6.5.dev8"
+__version__ = "0.6.5.dev9"

{sleipnirgroup_jormungandr-0.6.5.dev8 → sleipnirgroup_jormungandr-0.6.5.dev9}/python/test/autodiff/gradient_test.py

@@ -363,6 +363,20 @@ def test_abs():
     assert g.get().value()[0, 0] == 0.0
     assert g.value()[0, 0] == 0.0
 
+    f = autodiff.abs(x * x - 4.0)
+    g = Gradient(f, x)
+    symbolic_g = g.get()
+
+    x.set_value(3.0)
+    assert symbolic_g.value()[0, 0] == 6.0
+    assert g.value()[0, 0] == 6.0
+    assert g.get().value()[0, 0] == 6.0
+
+    x.set_value(1.0)
+    assert symbolic_g.value()[0, 0] == -2.0
+    assert g.value()[0, 0] == -2.0
+    assert g.get().value()[0, 0] == -2.0
+
 
 def test_atan2():
     x = Variable()

{sleipnirgroup_jormungandr-0.6.5.dev8 → sleipnirgroup_jormungandr-0.6.5.dev9}/python/test/autodiff/hessian_test.py

@@ -209,6 +209,62 @@ def test_nested_powers():
     assert H[0, 0] == pytest.approx(12 * x0 * x0, abs=1e-12)
 
 
+def test_max_and_min():
+    input = VariableMatrix(2)
+    expected_y = np.array([[0.0, 0.0], [0.0, 2.0]])
+    expected_x = np.array([[2.0, 0.0], [0.0, 0.0]])
+
+    def check(f, x0, y0, x1, y1):
+        hessian = Hessian(f, input)
+        symbolic_H = hessian.get()
+
+        input[0].set_value(x0)
+        input[1].set_value(y0)
+        np.testing.assert_array_equal(symbolic_H.value(), expected_y)
+        np.testing.assert_array_equal(hessian.value().todense(), expected_y)
+
+        input[0].set_value(x1)
+        input[1].set_value(y1)
+        np.testing.assert_array_equal(symbolic_H.value(), expected_x)
+        np.testing.assert_array_equal(hessian.value().todense(), expected_x)
+
+        input[0].set_value(2.0)
+        input[1].set_value(2.0)
+        np.testing.assert_array_equal(symbolic_H.value(), expected_x)
+        np.testing.assert_array_equal(hessian.value().todense(), expected_x)
+
+    x_squared = input[0] * input[0]
+    y_squared = input[1] * input[1]
+    check(autodiff.max(x_squared, y_squared), 1.0, 2.0, 3.0, 2.0)
+    check(autodiff.min(x_squared, y_squared), 2.0, 1.0, 2.0, 3.0)
+
+
+def test_pow():
+    input = VariableMatrix(2)
+    f = autodiff.pow(input[0] + 1.0, input[1])
+    hessian = Hessian(f, input)
+
+    symbolic_H = hessian.get()
+
+    input[0].set_value(2.0)
+    input[1].set_value(3.0)
+    mixed = 9.0 * (1.0 + 3.0 * math.log(3.0))
+    expected = np.array([[18.0, mixed], [mixed, 27.0 * math.log(3.0) ** 2]])
+    np.testing.assert_allclose(symbolic_H.value(), expected, rtol=0.0, atol=1e-12)
+    np.testing.assert_allclose(
+        hessian.value().todense(), expected, rtol=0.0, atol=1e-12
+    )
+
+    input[0].set_value(3.0)
+    input[1].set_value(2.0)
+    mixed = 4.0 * (1.0 + 2.0 * math.log(4.0))
+    expected = np.array([[2.0, mixed], [mixed, 16.0 * math.log(4.0) ** 2]])
+    np.testing.assert_allclose(symbolic_H.value(), expected, rtol=0.0, atol=1e-12)
+    np.testing.assert_allclose(
+        hessian.value().todense(), expected, rtol=0.0, atol=1e-12
+    )
+
+
 def test_rosenbrock():
     # z = (1 − x)² + 100(y − x²)²
     #   = 100(−x² + y)² + (−x + 1)²