gotranx 2.3.0__tar.gz → 2.4.0__tar.gz

{gotranx-2.3.0/src/gotranx.egg-info → gotranx-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gotranx
-Version: 2.3.0
+Version: 2.4.0
 Summary: A declarative language describing ordinary differential equations
 Author-email: Henrik Finsberg <henriknf@simula.no>
 License: MIT

{gotranx-2.3.0 → gotranx-2.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gotranx"
-version = "2.3.0"
+version = "2.4.0"
 description = "A declarative language describing ordinary differential equations"
 authors = [{name = "Henrik Finsberg", email = "henriknf@simula.no"}]
 license = {text = "MIT"}
@@ -172,7 +172,7 @@ tag = true
 sign_tags = false
 tag_name = "v{new_version}"
 tag_message = "Bump version: {current_version} → {new_version}"
-current_version = "2.3.0"
+current_version = "2.4.0"
 
 
 [[tool.bumpversion.files]]

{gotranx-2.3.0 → gotranx-2.4.0}/src/gotranx/codegen/python.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+import functools
 import typing
 from enum import Enum
 from sympy.printing.pycode import PythonCodePrinter
@@ -46,6 +47,15 @@ class GotranPythonCodePrinter(PythonCodePrinter):
     def _print_Float(self, flt):
         return self._print(str(float(flt)))
 
+    def _print_Min(self, expr):
+        # numpy.min(a, b) would read b as an axis; numpy.minimum takes two arrays
+        args = [self._print(arg) for arg in expr.args]
+        return functools.reduce(lambda x, y: f"numpy.minimum({x}, {y})", args)
+
+    def _print_Max(self, expr):
+        args = [self._print(arg) for arg in expr.args]
+        return functools.reduce(lambda x, y: f"numpy.maximum({x}, {y})", args)
+
     def _print_Piecewise(self, expr):
         result = []
 

{gotranx-2.3.0 → gotranx-2.4.0}/src/gotranx/myokit.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 from collections import defaultdict
+import functools
 import re
 import warnings
 from pathlib import Path
@@ -346,6 +347,43 @@ def myokit_to_gotran(model: "myokit.Model", protocol=None) -> ODE:
     )
 
 
+def _sympy_reader(model: "myokit.Model") -> "myokit.formats.sympy.SymPyExpressionReader":
+    """myokit's sympy expression reader, extended to read ``Min``, ``Max`` and n-ary
+    ``And``/``Or``.
+
+    myokit has no min or max, and its ``And`` and ``Or`` take exactly two operands where sympy's
+    take any number. Rewriting ``Min``/``Max`` as sympy ``Piecewise`` first does not work: a
+    ``Piecewise`` nested in a condition, as in the clamp ``Min(Max(x, 0), 1)``, becomes an ``ITE``,
+    which the reader cannot read either, and four or more arguments produce an n-ary ``And``. So
+    each ``Min``/``Max`` is read into nested myokit ``If`` expressions, and ``And``/``Or`` are
+    folded into nested binary ones.
+    """
+
+    class Reader(myokit.formats.sympy.SymPyExpressionReader):
+        def _build_op_map(self):
+            op_map = super()._build_op_map()
+            op_map[sp.Min] = self._ex_min
+            op_map[sp.Max] = self._ex_max
+            return op_map
+
+        def _fold(self, e, combine):
+            return functools.reduce(combine, [self.ex(arg) for arg in e.args])
+
+        def _ex_min(self, e):
+            return self._fold(e, lambda a, b: myokit.If(myokit.LessEqual(a, b), a, b))
+
+        def _ex_max(self, e):
+            return self._fold(e, lambda a, b: myokit.If(myokit.MoreEqual(a, b), a, b))
+
+        def _ex_and(self, e):
+            return self._fold(e, myokit.And)
+
+        def _ex_or(self, e):
+            return self._fold(e, myokit.Or)
+
+    return Reader(model=model)
+
+
 def gotran_to_myokit(ode: ODE, time_component="engine", time_unit="s") -> "myokit.Model":
     """Convert a gotran ODE to myokit model
 
@@ -420,7 +458,7 @@ def gotran_to_myokit(ode: ODE, time_component="engine", time_unit="s") -> "myoki
             var.set_unit(to_myokit_unit(intermediate.unit_str))
             global_var_map[intermediate.symbol] = sp.Symbol(var.qname())
 
-    sympy_reader = myokit.formats.sympy.SymPyExpressionReader(model=model)
+    sympy_reader = _sympy_reader(model)
     # Then we can add expressions
     for component in ode.components:
         comp = model[component_name_map[component.name]]

{gotranx-2.3.0 → gotranx-2.4.0}/src/gotranx/ode.lark

@@ -55,6 +55,8 @@ variable: VARIABLE
     | ABSL
     | FLOOR
     | MOD
+    | MIN
+    | MAX
 
 ?logicalfunc: logicalfuncname "(" expression ("," expression)* (",")?  ")"
 ?logicalfuncname: CONTINUOUSCONDITIONAL
@@ -93,6 +95,8 @@ OR: "Or"
 EQ: "Eq"
 NOT: "Not"
 MOD: "Mod"
+MIN: "Min"
+MAX: "Max"
 
 
 PI: "pi"

{gotranx-2.3.0 → gotranx-2.4.0}/src/gotranx/singularities.py

@@ -300,7 +300,7 @@ def _depending_on(
     """Cached front for :func:`_compute_depending_on`.
 
     Called once per (assignment, variable) pair against the same model, so
-    recomputing the fixed point every time dominated the scan. The cache holds
+    recomputing the dependents every time dominated the scan. The cache holds
     only the most recent ``definitions`` object and compares by identity, so it
     can never serve a stale answer for a different model.
     """
@@ -313,25 +313,47 @@ def _depending_on(
     return set(by_seeds[key])
 
 
+_USERS_CACHE: list = []
+
+
+def _users(
+    definitions: Mapping[sympy.Symbol, sympy.Expr],
+) -> dict[sympy.Symbol, list[sympy.Symbol]]:
+    """Every symbol mapped to the symbols whose definitions use it.
+
+    The reverse of ``definitions``' dependency graph. Built once per
+    ``definitions`` object and cached by identity, as :func:`_depending_on`
+    caches its answers, since a model asks for the dependents of every state.
+    """
+    if not _USERS_CACHE or _USERS_CACHE[0] is not definitions:
+        users: dict[sympy.Symbol, list[sympy.Symbol]] = {}
+        for symbol, definition in definitions.items():
+            for used in definition.free_symbols:
+                users.setdefault(used, []).append(symbol)
+        _USERS_CACHE[:] = [definitions, users]
+    return _USERS_CACHE[1]
+
+
 def _compute_depending_on(
     definitions: Mapping[sympy.Symbol, sympy.Expr],
     seeds: set[sympy.Symbol],
 ) -> set[sympy.Symbol]:
     """Symbols in ``definitions`` that transitively depend on any of ``seeds``.
 
-    ``definitions`` is not guaranteed to be topologically sorted, so this
-    iterates to a fixed point rather than assuming one pass suffices.
+    Walks the reverse dependency graph (:func:`_users`) out from the seeds, so
+    the cost is linear in the graph whatever order ``definitions`` is in. A
+    fixed-point sweep over ``definitions``, which is not guaranteed to be
+    topologically sorted, cost a pass per level of dependency for every set of
+    seeds, which made the scan quadratic in the size of a model.
     """
+    users = _users(definitions)
     dependent: set[sympy.Symbol] = set()
-    changed = True
-    while changed:
-        changed = False
-        for symbol, definition in definitions.items():
-            if symbol in dependent:
-                continue
-            if (definition.free_symbols & seeds) or (definition.free_symbols & dependent):
-                dependent.add(symbol)
-                changed = True
+    stack = list(seeds)
+    while stack:
+        for user in users.get(stack.pop(), ()):
+            if user not in dependent:
+                dependent.add(user)
+                stack.append(user)
     return dependent
 
 
@@ -441,7 +463,15 @@ def _numeric(expr: sympy.Expr, defaults: Mapping[sympy.Symbol, float]) -> float
     None means "not usable as a guard location or as a check point": complex,
     infinite, NaN, or still carrying a free symbol ``defaults`` does not cover.
     """
-    substituted = expr.xreplace({symbol: sympy.Float(x) for symbol, x in defaults.items()})
+    # Only the expression's own symbols: converting every default in the model
+    # on every call made evaluating all of a model's defaults quadratic.
+    substituted = expr.xreplace(
+        {
+            symbol: sympy.Float(defaults[symbol])
+            for symbol in expr.free_symbols
+            if symbol in defaults
+        }
+    )
     try:
         value = complex(substituted.evalf())
     except (TypeError, ValueError, AttributeError):
@@ -1081,7 +1111,7 @@ def default_values(
     """
     values = dict(base)
     for symbol, definition in definitions.items():
-        if not definition.free_symbols <= set(values):
+        if not definition.free_symbols <= values.keys():
             continue
         try:
             value = _numeric(definition, values)

{gotranx-2.3.0 → gotranx-2.4.0/src/gotranx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gotranx
-Version: 2.3.0
+Version: 2.4.0
 Summary: A declarative language describing ordinary differential equations
 Author-email: Henrik Finsberg <henriknf@simula.no>
 License: MIT

{gotranx-2.3.0 → gotranx-2.4.0}/src/gotranx.egg-info/SOURCES.txt

@@ -74,6 +74,7 @@ tests/test_julia_codegen.py
 tests/test_linearization.py
 tests/test_load.py
 tests/test_markdown_codegen.py
+tests/test_min_max.py
 tests/test_mtk_codegen.py
 tests/test_myokit.py
 tests/test_ode.py

{gotranx-2.3.0 → gotranx-2.4.0}/tests/test_benchmarks.py

@@ -57,3 +57,20 @@ def test_c_explicit_euler(ode):
 @pytest.mark.benchmark
 def test_c_generalized_rush_larsen(ode):
     gotranx.cli.gotran2c.get_code(ode, scheme=[gotranx.schemes.Scheme.generalized_rush_larsen])
+
+
+def _many_divisions(n):
+    """n states, each rate divided by a sum of states: denominators the scan rejects."""
+    states = ", ".join(f"y{i} = 0.5" for i in range(n))
+    lines = ['parameters("m", k = 0.01)', f'states("m", {states})', 'expressions("m")']
+    for i in range(n):
+        j = (i + 1) % n
+        lines.append(f"r{i} = y{i}/(y{i} + y{j} + 1.0)")
+        lines.append(f"dy{i}_dt = -k*r{i} + k*r{j}")
+    return "\n".join(lines) + "\n"
+
+
+@pytest.mark.benchmark
+def test_load_many_divisions():
+    ode = gotranx.load.ode_from_string(_many_divisions(500))
+    assert ode.num_states == 500

gotranx-2.4.0/tests/test_min_max.py

@@ -0,0 +1,184 @@
+"""`Min` and `Max` in the `.ode` language, through every backend."""
+
+import math
+
+import lark
+import numpy
+import pytest
+import sympy
+
+import gotranx
+from gotranx.cli import gotran2c, gotran2julia, gotran2mtk, gotran2py, gotran2ufl
+from gotranx.codegen.c import Format as CFormat
+from gotranx.load import ode_from_string
+from gotranx.schemes import Scheme
+
+MODEL = """
+parameters("m", k = 0.5)
+states("m", y = 0.5)
+expressions("m")
+r = k*Max(y - 0.2, 0.0, 2.0*y - 3.0) + Min(y, 1.0, k)
+dy_dt = -r
+"""
+# Both sides of every kink, and exactly on each: Max switches at 0.2 and 2.8, and Min at y = 1.0
+# and y = k. With k = 0.5 the 1.0 in Min is never the smallest, so the per-cell test uses k = 1.5
+# as well.
+Y = numpy.array([-1.0, 0.0, 0.1, 0.2, 0.3, 0.5, 0.9, 1.0, 1.5, 2.0, 2.8, 3.0, 3.5])
+
+
+def _generated(module, ode, **kwargs):
+    namespace: dict = {}
+    exec(compile(module.get_code(ode, **kwargs), f"<{module.__name__}>", "exec"), namespace)
+    return namespace
+
+
+def _expected_rhs(y, k=0.5):
+    largest = numpy.maximum(numpy.maximum(y - 0.2, 0.0), 2.0 * y - 3.0)
+    smallest = numpy.minimum(numpy.minimum(y, 1.0), k)
+    return -(k * largest + smallest)
+
+
+def test_min_max_parse_to_sympy():
+    r = ode_from_string(MODEL)["r"].expr
+    assert r.has(sympy.Max) and r.has(sympy.Min)
+
+
+def test_names_starting_with_min_or_max_are_still_variables():
+    ode = ode_from_string(
+        "parameters(Max_rate = 1.0, Minimum = 2.0, min = 3.0, max = 4.0)\n"
+        "states(y = 0.0)\n"
+        "dy_dt = Max_rate - Minimum*y + max - min\n"
+    )
+    assert {p.name for p in ode.parameters} == {"Max_rate", "Minimum", "min", "max"}
+
+
+def test_min_and_max_are_reserved_in_expressions():
+    with pytest.raises(lark.exceptions.UnexpectedToken):
+        ode_from_string("parameters(Max = 1.0)\nstates(y = 0.0)\ndy_dt = Max*y\n")
+
+
+def test_numpy_rhs_is_numpy_minimum_maximum():
+    ns = _generated(gotran2py, ode_from_string(MODEL))
+    values = ns["rhs"](0.0, Y[None, :], ns["init_parameter_values"]())
+    numpy.testing.assert_allclose(values[0], _expected_rhs(Y), rtol=1e-13, atol=1e-15)
+
+
+def test_numpy_rhs_with_per_cell_parameters():
+    ns = _generated(gotran2py, ode_from_string(MODEL))
+    y, k = (a.ravel() for a in numpy.meshgrid(Y, [0.5, 1.5]))  # k on both sides of 1.0
+    parameters = numpy.repeat(ns["init_parameter_values"]()[:, None], y.size, axis=1)
+    parameters[ns["parameter_index"]("k")] = k
+    values = ns["rhs"](0.0, y[None, :], parameters)
+    numpy.testing.assert_allclose(values[0], _expected_rhs(y, k), rtol=1e-13, atol=1e-15)
+
+
+def test_grl_through_max_is_exact_on_each_side():
+    ode = ode_from_string(
+        "parameters(k = 2.0, c = 0.5)\nstates(y = 0.0)\ndy_dt = c - k*Max(y - 0.2, 0.0)\n"
+    )
+    ns = _generated(gotran2py, ode, scheme=[Scheme.generalized_rush_larsen])
+    y0 = numpy.array([[0.0, 0.1, 0.2, 0.5, 1.0]])
+    dt, k, c = 0.1, 2.0, 0.5
+    # numpy.where evaluates both branches: the Rush-Larsen quotient is 0/0 where the rate is 0
+    with numpy.errstate(divide="ignore", invalid="ignore"):
+        y1 = ns["generalized_rush_larsen"](y0, 0.0, dt, ns["init_parameter_values"]())
+    # Flat side: the linearization is 0, so the step is forward Euler. Steep side: exact for the
+    # linear dy/dt = c - k*(y - 0.2), whose fixed point is 0.2 + c/k.
+    fixed = 0.2 + c / k
+    expected = numpy.where(y0 < 0.2, y0 + c * dt, fixed + (y0 - fixed) * math.exp(-k * dt))
+    off_kink = y0 != 0.2
+    numpy.testing.assert_allclose(y1[off_kink], expected[off_kink], rtol=1e-12)
+    assert numpy.isfinite(y1).all()
+
+
+def test_jax_prints_numpy_maximum():
+    code = gotran2py.get_code(ode_from_string(MODEL), backend=gotran2py.Backend.jax)
+    assert "numpy.maximum(" in code and "numpy.minimum(" in code
+    assert "numpy.max(" not in code and "numpy.min(" not in code
+
+
+def test_max_keeps_a_removable_pole_guarded():
+    ode = ode_from_string(
+        "states(y = -50.0)\nr = (y + 40.0)/(exp((y + 40.0)/10.0) - 1.0)*Max(y, -60.0)\ndy_dt = -r\n"
+    )
+    assert isinstance(ode["r"].expr, sympy.Piecewise)
+    ns = _generated(gotran2py, ode)
+    # numpy.where evaluates both branches: the unguarded one is 0/0 at the pole
+    with numpy.errstate(divide="ignore", invalid="ignore"):
+        values = ns["rhs"](0.0, numpy.array([[-40.0, -30.0]]), ns["init_parameter_values"]())
+    # x/(exp(x/10) - 1) -> 10 at x = 0, times Max(-40, -60) = -40
+    numpy.testing.assert_allclose(values[0], [400.0, 30.0 * 10.0 / (math.e - 1.0)], rtol=1e-6)
+
+
+EXPORTED = [
+    "k*Max(y - 0.2, 0.0, 2.0*y - 3.0) + Min(y, 1.0, k)",  # MODEL's r
+    "Min(Max(y, 0.0), 1.0)",  # the clamp in docs/grammar.md
+    "Max(Min(y, 1.0), k)",
+    "Conditional(Ge(Max(y, 0.0), k), y, k)",
+    "Max(Conditional(Gt(y, 0.0), y, -y), k)",
+    "Max(y, 0.1, k, 2.0*y - 1.0)",  # four arguments
+    "Min(y, 1.0, k, y*y, -y)",  # five
+    "Conditional(And(Gt(y, 0.0), Lt(y, 1.0), Gt(k, 0.0)), y, k)",  # a three-way And
+]
+
+
+@pytest.mark.parametrize("expr", EXPORTED)
+def test_myokit_export_evaluates_like_numpy(expr):
+    pytest.importorskip("myokit")
+    from gotranx.myokit import gotran_to_myokit
+
+    ode = ode_from_string(
+        f'parameters("m", k = 0.5)\nstates("m", y = 0.5)\nexpressions("m")\nr = {expr}\n'
+        "dy_dt = -r\n"
+    )
+    model = gotran_to_myokit(ode)
+    r = next(v for v in model.variables(deep=True) if v.name() == "r")
+    y = next(v for v in model.variables(deep=True) if v.name() == "y")
+    ns = _generated(gotran2py, ode)
+    parameters = ns["init_parameter_values"]()
+    for value in (-1.0, 0.0, 0.3, 0.5, 0.8, 1.0, 2.0, 3.0):
+        y.set_initial_value(value)
+        expected = -ns["rhs"](0.0, numpy.array([value]), parameters)[0]
+        assert r.eval() == pytest.approx(expected, rel=1e-12, abs=1e-15), value
+
+
+def test_cellml_export_of_the_clamp(tmp_path):
+    pytest.importorskip("myokit")
+    from gotranx.myokit import gotran_to_cellml
+
+    ode = ode_from_string("states(y = 0.5)\nr = Min(Max(y, 0.0), 1.0)\ndy_dt = -r\n")
+    gotran_to_cellml(ode, filename=tmp_path / "clamp.cellml")
+    assert (tmp_path / "clamp.cellml").read_text().count("<piecewise>") >= 2
+
+
+def test_c_prints_fmin_fmax():
+    # format=none: clang-format may be absent
+    code = gotran2c.get_code(ode_from_string(MODEL), format=CFormat.none)
+    assert "fmax(" in code and "fmin(" in code
+
+
+def test_ufl_min_max_evaluate_like_numpy():
+    pytest.importorskip("ufl")
+    ode = ode_from_string(MODEL)
+    ufl_ns = _generated(gotran2ufl, ode)
+    py_ns = _generated(gotran2py, ode)
+    for k in (0.5, 1.5):  # k on both sides of 1.0, so each argument of Min is the smallest
+        params = [float(p) for p in py_ns["init_parameter_values"](k=k)]
+        for y in (0.1, 0.2, 0.5, 1.2, 1.5, 3.0):
+            value = float(ufl_ns["rhs"](0.0, [y], params)[0])
+            assert value == pytest.approx(_expected_rhs(numpy.array(y), k), rel=1e-12), (k, y)
+
+
+@pytest.mark.parametrize("module", [gotran2julia, gotran2mtk])
+def test_julia_and_mtk_print_without_sympy_names(module):
+    code = module.get_code(ode_from_string(MODEL))
+    assert "Max(" not in code and "Min(" not in code
+
+
+def test_save_and_load_round_trip(tmp_path):
+    ode = ode_from_string(MODEL)
+    ode.save(tmp_path / "m.ode")
+    again = gotranx.load_ode(tmp_path / "m.ode")
+    ns, ns2 = _generated(gotran2py, ode), _generated(gotran2py, again)
+    p = ns["init_parameter_values"]()
+    numpy.testing.assert_array_equal(ns["rhs"](0.0, Y[None, :], p), ns2["rhs"](0.0, Y[None, :], p))

{gotranx-2.3.0 → gotranx-2.4.0}/tests/test_singularities.py

@@ -2,6 +2,9 @@
 
 from __future__ import annotations
 
+import random
+
+import pytest
 import sympy
 
 from gotranx import singularities
@@ -477,3 +480,48 @@ def test_half_width_does_not_depend_on_one_ulp_differences_in_exp(monkeypatch):
         monkeypatch.setattr(sympy, "lambdify", noisy_lambdify)
         assert singularities.half_width(ghk, v, sympy.Integer(0), 3, {}) == reference, seed
         monkeypatch.setattr(sympy, "lambdify", original)
+
+
+def _fixed_point_depending_on(definitions, seeds):
+    """The algorithm on main at d17b977, kept as the reference."""
+    dependent, changed = set(), True
+    while changed:
+        changed = False
+        for symbol, definition in definitions.items():
+            if symbol not in dependent and definition.free_symbols & (seeds | dependent):
+                dependent.add(symbol)
+                changed = True
+    return dependent
+
+
+@pytest.mark.parametrize("seed", range(20))
+def test_depending_on_matches_the_fixed_point(seed):
+    rng = random.Random(seed)
+    leaves, inner = sympy.symbols("a0:10"), sympy.symbols("s0:50")
+    known, definitions = list(leaves), {}
+    for s in inner:
+        definitions[s] = sympy.Add(*rng.sample(known, rng.randint(1, 3)))
+        known.append(s)
+    items = list(definitions.items())
+    rng.shuffle(items)  # not in dependency order: one pass is not enough
+    definitions = dict(items)
+    seeds = set(rng.sample(leaves, rng.randint(1, 3)))
+    if seed % 2:
+        seeds.add(rng.choice(inner))
+    assert singularities._compute_depending_on(definitions, seeds) == _fixed_point_depending_on(
+        definitions, seeds
+    )
+
+
+def test_depending_on_does_not_reuse_another_models_graph():
+    a, b, x = sympy.symbols("a b x")
+    first, second = {x: a + 1}, {x: b + 1}
+    assert singularities._depending_on(first, {a}) == {x}
+    assert singularities._depending_on(second, {a}) == set()
+    assert singularities._depending_on(second, {b}) == {x}
+
+
+def test_numeric_substitutes_only_the_expressions_own_symbols():
+    a, unrelated = sympy.symbols("a unrelated")
+    # sympy.Float("not a number") raises, so only `a`'s default may be converted
+    assert singularities._numeric(a + 1, {a: 2.0, unrelated: "not a number"}) == 3.0