sleipnirgroup-jormungandr 0.6.7.dev72__tar.gz → 0.6.7.dev74__tar.gz

{sleipnirgroup_jormungandr-0.6.7.dev72 → sleipnirgroup_jormungandr-0.6.7.dev74}/CMakeLists.txt

@@ -36,6 +36,11 @@ option(
     "Enable projecting the state onto bound inequality constraints inside problem setup"
     OFF
 )
+set(SLEIPNIR_TEST_SCALAR_TYPES
+    "double"
+    CACHE STRING
+    "Semicolon-separated list of scalar types to test (double, ExplicitDouble)"
+)
 
 # Options for using a package manager (e.g., vcpkg) for certain dependencies
 option(SLEIPNIR_USE_SYSTEM_BENCHMARK "Use system benchmark" OFF)
@@ -231,52 +236,98 @@ if(PROJECT_IS_TOP_LEVEL AND BUILD_TESTING AND NOT CMAKE_CROSSCOMPILING)
     list(APPEND CMAKE_MODULE_PATH ${Catch2_SOURCE_DIR}/extras)
     include(Catch)
 
-    # Build autodiff explicit instantiations shared by autodiff and
-    # optimization tests
-    file(
-        GLOB_RECURSE sleipnir_autodiff_explicit_double_src
-        test/src/autodiff/*_explicit_double.cpp
-    )
-    add_library(
-        sleipnir_autodiff_explicit_double
-        OBJECT
-        ${sleipnir_autodiff_explicit_double_src}
-    )
-    compiler_flags(sleipnir_autodiff_explicit_double)
-    target_include_directories(
-        sleipnir_autodiff_explicit_double
-        PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/test/include
-    )
-    target_link_libraries(sleipnir_autodiff_explicit_double PUBLIC Sleipnir)
+    set(sleipnir_allowed_test_scalar_types double ExplicitDouble)
+    foreach(type IN LISTS SLEIPNIR_TEST_SCALAR_TYPES)
+        if(NOT type IN_LIST sleipnir_allowed_test_scalar_types)
+            message(
+                FATAL_ERROR
+                "Unknown scalar type \"${type}\" in SLEIPNIR_TEST_SCALAR_TYPES"
+            )
+        endif()
+    endforeach()
+    if(NOT SLEIPNIR_TEST_SCALAR_TYPES)
+        message(FATAL_ERROR "SLEIPNIR_TEST_SCALAR_TYPES is empty")
+    endif()
+    list(JOIN SLEIPNIR_TEST_SCALAR_TYPES "," sleipnir_test_scalar_types)
+
+    if("ExplicitDouble" IN_LIST SLEIPNIR_TEST_SCALAR_TYPES)
+        # Build autodiff explicit instantiations
+        file(
+            GLOB_RECURSE sleipnir_autodiff_explicit_src
+            test/src/autodiff/*_explicit_double.cpp
+        )
+        add_library(
+            sleipnir_autodiff_explicit
+            OBJECT
+            ${sleipnir_autodiff_explicit_src}
+        )
+        compiler_flags(sleipnir_autodiff_explicit)
+        target_include_directories(
+            sleipnir_autodiff_explicit
+            PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/test/include
+        )
+        target_link_libraries(sleipnir_autodiff_explicit PUBLIC Sleipnir)
+
+        # Build optimization explicit instantiations
+        file(
+            GLOB_RECURSE sleipnir_optimization_explicit_src
+            test/src/optimization/*_explicit_double.cpp
+        )
+        add_library(
+            sleipnir_optimization_explicit
+            OBJECT
+            ${sleipnir_optimization_explicit_src}
+        )
+        compiler_flags(sleipnir_optimization_explicit)
+        target_include_directories(
+            sleipnir_optimization_explicit
+            PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/test/include
+        )
+        target_link_libraries(sleipnir_optimization_explicit PUBLIC Sleipnir)
+    endif()
 
     # Build Sleipnir autodiff tests
     file(GLOB_RECURSE sleipnir_autodiff_test_src test/src/autodiff/*_test.cpp)
     add_executable(sleipnir_autodiff_test ${sleipnir_autodiff_test_src})
     compiler_flags(sleipnir_autodiff_test)
+    target_compile_definitions(
+        sleipnir_autodiff_test
+        PRIVATE SCALAR_TYPES=${sleipnir_test_scalar_types}
+    )
     target_include_directories(
         sleipnir_autodiff_test
         PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/test/include
     )
     target_link_libraries(
         sleipnir_autodiff_test
-        PUBLIC Sleipnir sleipnir_autodiff_explicit_double Catch2::Catch2WithMain
+        PUBLIC
+            Sleipnir
+            $<TARGET_NAME_IF_EXISTS:sleipnir_autodiff_explicit>
+            Catch2::Catch2WithMain
     )
 
     # Build Sleipnir optimization tests
     file(
         GLOB_RECURSE sleipnir_optimization_test_src
-        test/src/optimization/*_explicit_double.cpp
         test/src/optimization/*_test.cpp
     )
     add_executable(sleipnir_optimization_test ${sleipnir_optimization_test_src})
     compiler_flags(sleipnir_optimization_test)
+    target_compile_definitions(
+        sleipnir_optimization_test
+        PRIVATE SCALAR_TYPES=${sleipnir_test_scalar_types}
+    )
     target_include_directories(
         sleipnir_optimization_test
         PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/test/include
     )
     target_link_libraries(
         sleipnir_optimization_test
-        PUBLIC Sleipnir sleipnir_autodiff_explicit_double Catch2::Catch2WithMain
+        PUBLIC
+            Sleipnir
+            $<TARGET_NAME_IF_EXISTS:sleipnir_autodiff_explicit>
+            $<TARGET_NAME_IF_EXISTS:sleipnir_optimization_explicit>
+            Catch2::Catch2WithMain
     )
 
     # Build Sleipnir util tests

{sleipnirgroup_jormungandr-0.6.7.dev72 → sleipnirgroup_jormungandr-0.6.7.dev74}/PKG-INFO

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

{sleipnirgroup_jormungandr-0.6.7.dev72 → sleipnirgroup_jormungandr-0.6.7.dev74}/python/src/sleipnir/__init__.py

@@ -2,4 +2,4 @@
 
 from ._sleipnir import *
 
-__version__ = "0.6.7.dev72"
+__version__ = "0.6.7.dev74"

{sleipnirgroup_jormungandr-0.6.7.dev72 → sleipnirgroup_jormungandr-0.6.7.dev74}/python/test/autodiff/hessian_test.py

@@ -1,6 +1,6 @@
 import math
 import operator
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from functools import reduce
 
 import numpy as np
@@ -210,6 +210,222 @@ def test_nested_powers() -> None:
     assert H[0, 0] == pytest.approx(12 * x0 * x0, abs=1e-12)
 
 
+def check_unary_hessian(
+    f: Callable[[Variable], Variable],
+    df: Callable[[float], float],
+    d2f: Callable[[float], float],
+) -> None:
+    # y = f(u) where u = x₀x₁
+    #
+    # ∂²y/∂x₀² = f″(u) x₁²
+    # ∂²y/∂x₀∂x₁ = f″(u) x₀x₁ + f′(u)
+    # ∂²y/∂x₁² = f″(u) x₀²
+    x = VariableMatrix(2)
+    x[0].set_value(0.6)
+    x[1].set_value(0.7)
+    hessian = Hessian(f(x[0] * x[1]), x)
+    symbolic_H = hessian.get()
+
+    # Check symbolic Hessian at a point other than where it was built too
+    for x0, x1 in [(0.6, 0.7), (0.3, 0.7)]:
+        x[0].set_value(x0)
+        x[1].set_value(x1)
+
+        u = x0 * x1
+        mixed = d2f(u) * u + df(u)
+        expected = np.array([[d2f(u) * x1 * x1, mixed], [mixed, d2f(u) * x0 * x0]])
+        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_division() -> None:
+    # y = x₀/x₁
+    #
+    # ∂²y/∂x₀² = 0
+    # ∂²y/∂x₀∂x₁ = −1/x₁²
+    # ∂²y/∂x₁² = 2x₀/x₁³
+    x = VariableMatrix(2)
+    hessian = Hessian(x[0] / x[1], x)
+    symbolic_H = hessian.get()
+
+    for x0, x1 in [(3.0, 2.0), (-1.5, 0.5)]:
+        x[0].set_value(x0)
+        x[1].set_value(x1)
+
+        mixed = -1.0 / (x1 * x1)
+        expected = np.array([[0.0, mixed], [mixed, 2.0 * x0 / (x1 * x1 * x1)]])
+        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_unary_minus() -> None:
+    check_unary_hessian(lambda u: -u, lambda u: -1.0, lambda u: 0.0)
+
+
+def test_abs() -> None:
+    check_unary_hessian(autodiff.abs, lambda u: 1.0, lambda u: 0.0)
+
+
+def test_acos() -> None:
+    check_unary_hessian(
+        autodiff.acos,
+        lambda u: -1.0 / math.sqrt(1.0 - u * u),
+        lambda u: -u / math.sqrt(1.0 - u * u) ** 3,
+    )
+
+
+def test_asin() -> None:
+    check_unary_hessian(
+        autodiff.asin,
+        lambda u: 1.0 / math.sqrt(1.0 - u * u),
+        lambda u: u / math.sqrt(1.0 - u * u) ** 3,
+    )
+
+
+def test_atan() -> None:
+    check_unary_hessian(
+        autodiff.atan,
+        lambda u: 1.0 / (1.0 + u * u),
+        lambda u: -2.0 * u / ((1.0 + u * u) * (1.0 + u * u)),
+    )
+
+
+def test_atan2() -> None:
+    # z = atan2(y, x)
+    #
+    # ∂²z/∂y² = −2xy/(x² + y²)²
+    # ∂²z/∂y∂x = (y² − x²)/(x² + y²)²
+    # ∂²z/∂x² = 2xy/(x² + y²)²
+    input = VariableMatrix(2)
+    hessian = Hessian(autodiff.atan2(input[0], input[1]), input)
+    symbolic_H = hessian.get()
+
+    for y, x in [(1.5, 0.5), (-0.7, 1.3)]:
+        input[0].set_value(y)
+        input[1].set_value(x)
+
+        d = x * x + y * y
+        mixed = (y * y - x * x) / (d * d)
+        expected = np.array(
+            [[-2.0 * x * y / (d * d), mixed], [mixed, 2.0 * x * y / (d * d)]]
+        )
+        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_cbrt() -> None:
+    check_unary_hessian(
+        autodiff.cbrt,
+        lambda u: 1.0 / (3.0 * math.cbrt(u) * math.cbrt(u)),
+        lambda u: -2.0 / (9.0 * u * math.cbrt(u) * math.cbrt(u)),
+    )
+
+
+def test_cos() -> None:
+    check_unary_hessian(autodiff.cos, lambda u: -math.sin(u), lambda u: -math.cos(u))
+
+
+def test_cosh() -> None:
+    check_unary_hessian(autodiff.cosh, math.sinh, math.cosh)
+
+
+def test_erf() -> None:
+    check_unary_hessian(
+        autodiff.erf,
+        lambda u: 2.0 / math.sqrt(math.pi) * math.exp(-u * u),
+        lambda u: -4.0 / math.sqrt(math.pi) * u * math.exp(-u * u),
+    )
+
+
+def test_exp() -> None:
+    check_unary_hessian(autodiff.exp, math.exp, math.exp)
+
+
+def hypot_expected_H(v: np.ndarray) -> np.ndarray:
+    # y = ‖v‖
+    #
+    # ∂²y/∂vᵢ∂vⱼ = (‖v‖²δᵢⱼ − vᵢvⱼ)/‖v‖³
+    r2 = v @ v
+    return (r2 * np.eye(len(v)) - np.outer(v, v)) / (r2 * math.sqrt(r2))
+
+
+def test_hypot_two_arguments() -> None:
+    x = VariableMatrix(2)
+    hessian = Hessian(autodiff.hypot(x[0], x[1]), x)
+    symbolic_H = hessian.get()
+
+    for x0, x1 in [(1.3, 2.3), (-0.5, 1.5)]:
+        x[0].set_value(x0)
+        x[1].set_value(x1)
+
+        expected = hypot_expected_H(np.array([x0, x1]))
+        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_hypot_three_arguments() -> None:
+    x = VariableMatrix(3)
+    hessian = Hessian(autodiff.hypot(x[0], x[1], x[2]), x)
+    symbolic_H = hessian.get()
+
+    for v in [np.array([1.3, 2.3, 3.3]), np.array([-0.5, 1.5, -2.5])]:
+        x[0].set_value(v[0])
+        x[1].set_value(v[1])
+        x[2].set_value(v[2])
+
+        expected = hypot_expected_H(v)
+        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_hypot_repeated_argument() -> None:
+    # y = hypot(a, b, a) = √(2a² + b²)
+    #
+    # ∂²y/∂a² = (2y² − 4a²)/y³
+    # ∂²y/∂a∂b = −2ab/y³
+    # ∂²y/∂b² = (y² − b²)/y³
+    x = VariableMatrix(2)
+    hessian = Hessian(autodiff.hypot(x[0], x[1], x[0]), x)
+    symbolic_H = hessian.get()
+
+    for a, b in [(1.3, 2.3), (-0.5, 1.5)]:
+        x[0].set_value(a)
+        x[1].set_value(b)
+
+        y2 = 2.0 * a * a + b * b
+        y3 = y2 * math.sqrt(y2)
+        mixed = -2.0 * a * b / y3
+        expected = np.array(
+            [[(2.0 * y2 - 4.0 * a * a) / y3, mixed], [mixed, (y2 - b * b) / y3]]
+        )
+        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_log() -> None:
+    check_unary_hessian(autodiff.log, lambda u: 1.0 / u, lambda u: -1.0 / (u * u))
+
+
+def test_log10() -> None:
+    check_unary_hessian(
+        autodiff.log10,
+        lambda u: 1.0 / (math.log(10.0) * u),
+        lambda u: -1.0 / (math.log(10.0) * u * u),
+    )
+
+
 def test_max_and_min() -> None:
     input = VariableMatrix(2)
     expected_y = np.array([[0.0, 0.0], [0.0, 2.0]])
@@ -266,6 +482,42 @@ def test_pow() -> None:
     )
 
 
+def test_sign() -> None:
+    check_unary_hessian(autodiff.sign, lambda u: 0.0, lambda u: 0.0)
+
+
+def test_sin() -> None:
+    check_unary_hessian(autodiff.sin, math.cos, lambda u: -math.sin(u))
+
+
+def test_sinh() -> None:
+    check_unary_hessian(autodiff.sinh, math.cosh, math.sinh)
+
+
+def test_sqrt() -> None:
+    check_unary_hessian(
+        autodiff.sqrt,
+        lambda u: 1.0 / (2.0 * math.sqrt(u)),
+        lambda u: -1.0 / (4.0 * u * math.sqrt(u)),
+    )
+
+
+def test_tan() -> None:
+    check_unary_hessian(
+        autodiff.tan,
+        lambda u: 1.0 / (math.cos(u) * math.cos(u)),
+        lambda u: 2.0 * math.tan(u) / (math.cos(u) * math.cos(u)),
+    )
+
+
+def test_tanh() -> None:
+    check_unary_hessian(
+        autodiff.tanh,
+        lambda u: 1.0 / (math.cosh(u) * math.cosh(u)),
+        lambda u: -2.0 * math.tanh(u) / (math.cosh(u) * math.cosh(u)),
+    )
+
+
 def test_rosenbrock() -> None:
     # z = (1 − x)² + 100(y − x²)²
     #   = 100(−x² + y)² + (−x + 1)²