gotranx 2.1.0__tar.gz → 2.2.0__tar.gz

{gotranx-2.1.0/src/gotranx.egg-info → gotranx-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gotranx
-Version: 2.1.0
+Version: 2.2.0
 Summary: A declarative language describing ordinary differential equations
 Author-email: Henrik Finsberg <henriknf@simula.no>
 License: MIT
@@ -47,6 +47,7 @@ Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: jax; extra == "test"
 Requires-Dist: cmake; extra == "test"
+Requires-Dist: fenics-ufl; extra == "test"
 Requires-Dist: gotranx[formatters]; extra == "test"
 Provides-Extra: benchmark
 Requires-Dist: pytest-benchmark>=4.0.0; extra == "benchmark"

{gotranx-2.1.0 → gotranx-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gotranx"
-version = "2.1.0"
+version = "2.2.0"
 description = "A declarative language describing ordinary differential equations"
 authors = [{name = "Henrik Finsberg", email = "henriknf@simula.no"}]
 license = {text = "MIT"}
@@ -62,6 +62,7 @@ test = [
     "pytest-cov",
     "jax",
     "cmake",
+    "fenics-ufl",
     "gotranx[formatters]",
 ]
 benchmark = [
@@ -171,7 +172,7 @@ tag = true
 sign_tags = false
 tag_name = "v{new_version}"
 tag_message = "Bump version: {current_version} → {new_version}"
-current_version = "2.1.0"
+current_version = "2.2.0"
 
 
 [[tool.bumpversion.files]]

{gotranx-2.1.0 → gotranx-2.2.0}/src/gotranx/codegen/ufl.py

@@ -74,6 +74,28 @@ class UFLPrinter(GotranPythonCodePrinter):
 
         return "".join(result)
 
+    # Comparisons are printed as calls to the ufl functions, not as Python
+    # operators. With two numbers as operands (say a parameter passed as a
+    # float) an operator gives a Python bool, which ufl.conditional, ufl.And
+    # and ufl.Or refuse; the functions convert both operands with ufl.as_ufl.
+    # `==` and `!=` never give a condition: UFL keeps them for structural
+    # equality of expressions.
+    _comparisons = {
+        "==": "ufl.eq",
+        "!=": "ufl.ne",
+        "<": "ufl.lt",
+        "<=": "ufl.le",
+        ">": "ufl.gt",
+        ">=": "ufl.ge",
+    }
+
+    def _print_Relational(self, expr):
+        func = self._comparisons[expr.rel_op]
+        return f"{func}({self._print(expr.lhs)}, {self._print(expr.rhs)})"
+
+    # The Python printer's own _print_Equality would otherwise take precedence
+    _print_Equality = _print_Relational
+
     def _print_And(self, expr):
         args = [self._print(arg) for arg in expr.args]
         return functools.reduce(lambda x, y: f"ufl.And({x}, {y})", args)

{gotranx-2.1.0 → gotranx-2.2.0}/src/gotranx/ode.py

@@ -280,7 +280,10 @@ def sort_assignments(
                 "Try to save the ODE to an .ode file first and load it again"
             )
             raise exceptions.GotranxError(msg)
-        sorter.add(assignment.name, *assignment.value.dependencies)
+        # sorted(): dependencies is a frozenset[str], and graphlib breaks ties in
+        # insertion order, so an unsorted splat leaks PYTHONHASHSEED into the
+        # emitted order of states, monitors and intermediates.
+        sorter.add(assignment.name, *sorted(assignment.value.dependencies))
 
     static_order = tuple(sorter.static_order())
 

{gotranx-2.1.0 → gotranx-2.2.0/src/gotranx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gotranx
-Version: 2.1.0
+Version: 2.2.0
 Summary: A declarative language describing ordinary differential equations
 Author-email: Henrik Finsberg <henriknf@simula.no>
 License: MIT
@@ -47,6 +47,7 @@ Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: jax; extra == "test"
 Requires-Dist: cmake; extra == "test"
+Requires-Dist: fenics-ufl; extra == "test"
 Requires-Dist: gotranx[formatters]; extra == "test"
 Provides-Extra: benchmark
 Requires-Dist: pytest-benchmark>=4.0.0; extra == "benchmark"

{gotranx-2.1.0 → gotranx-2.2.0}/src/gotranx.egg-info/SOURCES.txt

@@ -64,6 +64,7 @@ tests/test_comments.py
 tests/test_conditionals.py
 tests/test_deep_linearization_models.py
 tests/test_demos.py
+tests/test_determinism.py
 tests/test_expressions.py
 tests/test_julia_codegen.py
 tests/test_linearization.py

{gotranx-2.1.0 → gotranx-2.2.0}/src/gotranx.egg-info/requires.txt

@@ -52,4 +52,5 @@ pytest
 pytest-cov
 jax
 cmake
+fenics-ufl
 gotranx[formatters]

gotranx-2.2.0/tests/test_determinism.py

@@ -0,0 +1,89 @@
+"""Generated output must not depend on Python's per-process hash seed.
+
+``sort_assignments`` feeds ``graphlib.TopologicalSorter``, which breaks ties in
+insertion order. Any set of strings iterated on the way in therefore leaks
+``PYTHONHASHSEED`` into the emitted order of states, monitors and intermediates,
+and from there into the generated code.
+
+The seed must be set before the interpreter starts, so every check here shells
+out to a fresh interpreter rather than running in-process.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+here = Path(__file__).parent
+
+# Models with enough independent branches for a tie-break to be observable.
+# Small models have no ties to break, so they cannot expose this. These two produce a
+# distinct order on every seed tried.
+MODELS = ["ToRORd_dyn_chloride.ode", "ORdmm_Land.ode"]
+SEEDS = ("1", "2", "7")
+
+_ORDER_SCRIPT = """
+import json, sys
+import gotranx
+
+ode = gotranx.load_ode(sys.argv[1])
+# Marker-delimited: gotranx logs to stdout, so the payload cannot be the whole stream.
+print("<<<ORDER>>>" + json.dumps({
+    "assignments": [a.name for a in ode.sorted_assignments()],
+    "states": [s.name for s in ode.sorted_states()],
+}))
+"""
+
+_CODEGEN_SCRIPT = """
+import sys
+import gotranx
+
+ode = gotranx.load_ode(sys.argv[1])
+from gotranx.codegen import JuliaCodeGenerator
+codegen = JuliaCodeGenerator(ode)
+sys.stdout.write("<<<CODE>>>" + codegen.rhs() + codegen.monitor_index() + codegen.state_index())
+"""
+
+
+def _run(script: str, odefile: Path, seed: str, marker: str) -> str:
+    env = {**os.environ, "PYTHONHASHSEED": seed}
+    out = subprocess.run(
+        [sys.executable, "-c", script, str(odefile)],
+        env=env,
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    assert marker in out.stdout, f"marker missing; stderr was:\n{out.stderr}"
+    return out.stdout.split(marker, 1)[1]
+
+
+@pytest.mark.parametrize("model", MODELS)
+def test_assignment_and_state_order_are_independent_of_hash_seed(model):
+    odefile = here / "odefiles" / model
+    orders = [json.loads(_run(_ORDER_SCRIPT, odefile, s, "<<<ORDER>>>")) for s in SEEDS]
+
+    for seed, other in zip(SEEDS[1:], orders[1:]):
+        assert other["assignments"] == orders[0]["assignments"], (
+            f"assignment order under PYTHONHASHSEED={seed} differs from {SEEDS[0]}"
+        )
+        assert other["states"] == orders[0]["states"], (
+            f"state order under PYTHONHASHSEED={seed} differs from {SEEDS[0]}"
+        )
+
+
+@pytest.mark.parametrize("model", MODELS)
+def test_generated_code_is_independent_of_hash_seed(model):
+    """The end-to-end property users actually depend on."""
+    odefile = here / "odefiles" / model
+    code = [_run(_CODEGEN_SCRIPT, odefile, s, "<<<CODE>>>") for s in SEEDS]
+
+    for seed, other in zip(SEEDS[1:], code[1:]):
+        assert other == code[0], (
+            f"generated rhs under PYTHONHASHSEED={seed} differs from {SEEDS[0]}"
+        )

{gotranx-2.1.0 → gotranx-2.2.0}/tests/test_ufl_codegen.py

@@ -1,7 +1,10 @@
+import math
 import pytest
 from pathlib import Path
 import gotranx
+from gotranx.cli import gotran2py, gotran2ufl
 from gotranx.codegen.ufl import UFLCodeGenerator
+from gotranx.schemes import Scheme
 
 here = Path(__file__).parent.absolute()
 
@@ -117,3 +120,78 @@ def test_ufl_codegen_ordmm_land():
     # generated successfully as state array index mappings
     assert "hL = states[" in code
     assert "a = states[" in code
+
+
+def _generated(module, ode, scheme=None):
+    code = module.get_code(ode, scheme=scheme)
+    namespace: dict = {}
+    exec(compile(code, f"<{module.__name__}>", "exec"), namespace)
+    return namespace
+
+
+def test_ufl_generalized_rush_larsen_with_float_parameters():
+    """The generated UFL scheme accepts parameters that are plain Python floats.
+
+    The linearized rate of ``x`` is the parameter ``-k``, so the scheme's
+    zero-division guard ``|dx_dt_linearized| > delta`` compares two numbers.
+    Printed as ``>`` that is a Python ``bool``, which ``ufl.Or`` refuses.
+    """
+    pytest.importorskip("ufl")
+    from ufl.core.expr import Expr
+
+    ode = gotranx.load.ode_from_string(
+        """
+        parameters(k=2.0, c=1.0)
+        states(x=0.2)
+        dx_dt = c - k * x
+        """
+    )
+    scheme = [Scheme.generalized_rush_larsen]
+    ufl_code = _generated(gotran2ufl, ode, scheme)
+    py_code = _generated(gotran2py, ode, scheme)
+
+    states = py_code["init_state_values"]()
+    parameters = py_code["init_parameter_values"]()
+    dt = 0.1
+    expected = py_code["generalized_rush_larsen"](states, 0.0, dt, parameters)
+
+    values = ufl_code["generalized_rush_larsen"](
+        [float(s) for s in states], 0.0, dt, [float(p) for p in parameters]
+    )
+
+    assert isinstance(values[0], Expr)
+    assert float(values[0]) == pytest.approx(expected[0], rel=1e-12)
+    # The scheme is exact for a linear ODE: x(dt) = c/k + (x0 - c/k) exp(-k dt)
+    assert float(values[0]) == pytest.approx(0.5 - 0.3 * math.exp(-0.2), rel=1e-12)
+
+
+@pytest.mark.parametrize("b", [1.0, 2.0])
+@pytest.mark.parametrize(
+    "condition", ["Lt(a, b)", "Le(a, b)", "Gt(a, b)", "Ge(a, b)", "Eq(a, b)", "Not(Eq(a, b))"]
+)
+def test_ufl_relational_with_float_operands(condition, b):
+    """Every relational prints to a UFL condition, whatever its operands are.
+
+    Comparing two Python numbers gives a Python ``bool``, which
+    ``ufl.conditional`` refuses. ``==`` and ``!=`` never give a UFL condition,
+    even on UFL operands, since UFL reserves them for structural equality.
+    """
+    pytest.importorskip("ufl")
+
+    ode = gotranx.load.ode_from_string(
+        f"""
+        parameters(a=1.0, b=2.0)
+        states(x=0.0)
+        dx_dt = Conditional({condition}, 1.0, -1.0)
+        """
+    )
+    ufl_code = _generated(gotran2ufl, ode)
+    py_code = _generated(gotran2py, ode)
+
+    states = py_code["init_state_values"]()
+    parameters = py_code["init_parameter_values"](b=b)
+    expected = py_code["rhs"](0.0, states, parameters)
+
+    values = ufl_code["rhs"](0.0, [float(s) for s in states], [float(p) for p in parameters])
+
+    assert float(values[0]) == expected[0]