scikit-complexity 0.2.0__py3-none-any.whl

skcomplex/models/biology/collective_behaviour/_swimming.py

@@ -0,0 +1,66 @@
+"""Define swimming, which moves every fish of a shoal along its heading after an angular noise."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+import math
+from typing import Annotated, cast
+
+import numpy as np
+from sage.sets.real_set import RealSet
+
+from ....core.interactions import MovementInteraction
+from ....core.types import AgentViewProtocol, ModelViewProtocol
+from ....specs import ParameterSpec, RoleSpec
+from ._shoal_member_view import ShoalMemberView
+
+
+class SwimmingInteraction(MovementInteraction):
+    """Swim of every fish by `speed` along its heading, turned first by its angular noise `deviation`.
+
+    The heading `(vx, vy)` stays a unit vector, and the fish moves on the torus of side `size`.
+
+    Args:
+        label:
+            The label of the interaction, unique among the parts of its system.
+
+        target:
+            The path of the group of fish.
+
+        probability:
+            The probability that a fish swims in a step.
+
+        phase:
+            The phase of the step the swim runs in, or `None` for the default phase.
+
+    Examples:
+        >>> from skcomplex.models.biology.collective_behaviour import SwimmingInteraction
+        >>> SwimmingInteraction('swimming', target='shoal', phase='swim').phase
+        'swim'
+    """
+
+    def __init__(
+        self,
+        label: str,
+        *,
+        target: Annotated[str, RoleSpec()],
+        probability: Annotated[float, ParameterSpec(domain=RealSet.closed(0, 1))] = 1.0,
+        phase: str | None = None,
+    ) -> None:
+        super().__init__(
+            label,
+            target=target,
+            step=self._swim,
+            probability=probability,
+            schedule='member',
+            phase=phase,
+        )
+
+    @staticmethod
+    def _swim(agent: AgentViewProtocol, model: ModelViewProtocol) -> tuple[float, ...]:
+        """Turn the heading of a fish by its angular noise and return its position after one swim."""
+        fish = cast(ShoalMemberView, agent)
+        angle = math.atan2(fish.vy, fish.vx) + fish.deviation
+        fish.vx, fish.vy = math.cos(angle), math.sin(angle)
+        position = np.asarray(fish.location, dtype=float) + fish.speed * np.array([fish.vx, fish.vy])
+        return tuple(float(item) for item in np.mod(position, fish.size))

skcomplex/models/biology/collective_behaviour/_trail_choice.py

@@ -0,0 +1,105 @@
+"""Choice of a branch by arriving ants, with Deneubourg's probability `(k + n)^h / ((k + n)^h + (k + n')^h)`."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+from types import SimpleNamespace
+from typing import Annotated
+
+from sage.all__sagemath_symbolics import Expression, oo
+from sage.sets.real_set import RealSet
+
+from ....core.interactions import ReactionInteraction
+from ....specs import ParameterSpec, RoleSpec
+from ....types import Stoichiometry
+
+MODES = {False: 'rate', True: 'jump'}
+
+
+class TrailChoiceInteraction(ReactionInteraction):
+    """Choice of a branch by arriving ants, with Deneubourg's probability `(k + n)^h / ((k + n)^h + (k + n')^h)`.
+
+    Ants arrive at the fork at rate `flux`, and each takes the chosen branch with a probability that grows with its
+    marks `n` against the marks `n'` of the other branch, and marks it. It is a `ReactionInteraction` that produces one
+    mark on the chosen branch at that propensity and reads the other branch as a modifier, a rate equation, or in
+    stochastic mode a random event per ant.
+
+    Args:
+        label:
+            The label of the interaction.
+
+        chosen:
+            The path of the branch this choice marks.
+
+        other:
+            The path of the competing branch.
+
+        flux:
+            The rate at which ants arrive at the fork.
+
+        k:
+            The attractiveness of an unmarked branch.
+
+        h:
+            The nonlinearity of the choice.
+
+        stochastic:
+            Whether ants are random events.
+
+    Examples:
+        >>> from skcomplex.core.system import System
+        >>> from skcomplex.engine.runtime import Simulation
+        >>> from skcomplex.models.biology.collective_behaviour import BranchElement, TrailChoiceInteraction
+        >>> choice = TrailChoiceInteraction('choice', chosen='left', other='right', stochastic=False)
+        >>> system = System(elements=[BranchElement('left'), BranchElement('right')], interactions=[choice])
+        >>> trajectory = Simulation(system, dt=0.1).check().prepare().run(until=2.0).trajectory_
+        >>> round(float(trajectory.values('left.n')[-1]), 3)
+        1.025
+    """
+
+    def __init__(
+        self,
+        label: str,
+        *,
+        chosen: Annotated[str, RoleSpec()],
+        other: Annotated[str, RoleSpec()],
+        flux: Annotated[float, ParameterSpec(domain=RealSet.closed_open(0, oo))] = 1.0,
+        k: Annotated[float, ParameterSpec(domain=RealSet.closed_open(0, oo))] = 20.0,
+        h: Annotated[float, ParameterSpec(domain=RealSet.open(0, oo))] = 2.0,
+        stochastic: bool = True,
+    ) -> None:
+        super().__init__(label)
+        self.chosen = chosen
+        self.other = other
+        self.flux = flux
+        self.k = k
+        self.h = h
+        self.stochastic = stochastic
+
+    def _get_products(self) -> Stoichiometry:
+        """Return the marks `n` of the chosen branch, which every choice adds one to."""
+        return {(self.chosen, 'n'): 1}
+
+    def _get_modifiers(self) -> Stoichiometry:
+        """Return the marks `n` of the other branch, which the choice reads."""
+        return {(self.other, 'n'): 1}
+
+    def _get_mode(self) -> str:
+        """Return the mode of the reaction, random events when stochastic and a rate equation otherwise."""
+        return MODES[self.stochastic]
+
+    def _get_rate(self, namespace: SimpleNamespace) -> Expression:
+        """Return the rate of ants that choose the branch, `flux` times Deneubourg's probability.
+
+        Args:
+            namespace:
+                The namespace of the symbols the rate can use, with the chosen and the other branch.
+
+        Returns:
+            rate:
+                The propensity of the marking.
+        """
+        s = namespace
+        attraction = (s.k + s.chosen.n) ** s.h
+        propensity: Expression = s.flux * attraction / (attraction + (s.k + s.other.n) ** s.h)
+        return propensity

skcomplex/models/biology/collective_behaviour/_trails.py

@@ -0,0 +1,245 @@
+"""Collective behaviour models: active walkers that form trails by changing the ground they walk on."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+from types import SimpleNamespace
+from typing import cast
+
+import numpy as np
+from sage.all__sagemath_symbolics import Expression
+
+from ....core.elements import FieldElement, GroupElement
+from ....core.interactions import (
+    DiffusionInteraction,
+    LifeCycleInteraction,
+    MapInteraction,
+    MovementInteraction,
+    RelaxationInteraction,
+    TransferInteraction,
+)
+from ....core.laws import Source
+from ....core.spaces import LatticeSpace
+from ....core.system import System
+from ....core.types import AgentViewProtocol, ModelViewProtocol
+from ..._catalog import register_model
+from ._ground import GroundElement
+from ._walker import WalkerElement
+from ._walker_view import WalkerView
+
+TRAIL = 'land/ground.V'
+
+
+def _corners(width: int, height: int) -> list[tuple[int, int]]:
+    """Return the four corner cells of a grid, the entry points of the walkers."""
+    return [(0, 0), (width - 1, 0), (0, height - 1), (width - 1, height - 1)]
+
+
+def _get_durability(namespace: SimpleNamespace) -> Expression:
+    """Return the durability `T` of trails, the time over which the structure fades to bare ground."""
+    durability: Expression = namespace.target.T
+    return durability
+
+
+def _get_diffusion(namespace: SimpleNamespace) -> Expression:
+    """Return the diffusion coefficient `D` of the trail potential."""
+    coefficient: Expression = namespace.target.D
+    return coefficient
+
+
+def _get_structure(namespace: SimpleNamespace) -> Expression:
+    """Return the ground structure `G`, the goal of the trail potential."""
+    structure: Expression = namespace.target.G
+    return structure
+
+
+def _get_relaxation(namespace: SimpleNamespace) -> Expression:
+    """Return the relaxation time `tau` of the trail potential."""
+    time: Expression = namespace.target.tau
+    return time
+
+
+def _get_goal(walker: AgentViewProtocol | None, model: ModelViewProtocol) -> dict[str, object]:
+    """Return another entry point than the cell of a walker as its goal, drawn at random."""
+    if not isinstance(walker, WalkerView):
+        return {}
+    here = cast('tuple[int, int]', walker.location)
+    goals = [corner for corner in _corners(round(walker.width), round(walker.height)) if corner != here]
+    goal_x, goal_y = goals[int(model.rng.integers(len(goals)))]
+    return {'goal_x': float(goal_x), 'goal_y': float(goal_y)}
+
+
+def _arrived(walker: AgentViewProtocol, model: ModelViewProtocol) -> bool:
+    """Return whether a walker stands at its goal."""
+    del model
+    return isinstance(walker, WalkerView) and walker.location == (round(walker.goal_x), round(walker.goal_y))
+
+
+def _waits(walker: AgentViewProtocol, model: ModelViewProtocol) -> bool:
+    """Return whether a walker arrived at its goal in the previous step, so it leaves the green now."""
+    return _arrived(walker, model) and isinstance(walker, WalkerView) and bool(walker.arrived)
+
+
+def _walks(walker: AgentViewProtocol, model: ModelViewProtocol) -> bool:
+    """Return whether a walker is away from its goal, so it steps."""
+    return not _arrived(walker, model)
+
+
+def _get_arrived(walker: AgentViewProtocol, model: ModelViewProtocol) -> float:
+    """Return whether a walker stands at its goal at the end of its activation."""
+    return float(_arrived(walker, model))
+
+
+def _get_step(walker: AgentViewProtocol, model: ModelViewProtocol) -> object:
+    """Return a neighbouring cell drawn with a weight that grows with the alignment of the step with the heading.
+
+    The heading is the unit vector toward the goal plus `attraction` times the gradient of the trail potential, and the
+    weight of a step is `exp(directedness * cos angle)`, where the angle is between the step and the heading.
+    """
+    if not isinstance(walker, WalkerView):
+        return None
+    x, y = cast('tuple[int, int]', walker.location)
+    cells = cast('list[tuple[int, int]]', list(walker.neighbor_cells()))
+    goal = np.array([walker.goal_x - x, walker.goal_y - y])
+    steps = np.array([(cell[0] - x, cell[1] - y) for cell in cells], dtype=float)
+    lengths = np.hypot(steps[:, 0], steps[:, 1])
+    rises = np.array([model.field(TRAIL, cell) for cell in cells]) - model.field(TRAIL, (x, y))
+    slope = 2 * (steps / lengths[:, None] ** 2).T @ rises / len(cells)
+    heading = goal / max(float(np.hypot(*goal)), 1e-12) + walker.attraction * slope
+    alignment = steps @ heading / (lengths * max(float(np.hypot(*heading)), 1e-12))
+    weights = np.exp(walker.directedness * (alignment - alignment.max()))
+    return cells[int(model.rng.choice(len(cells), p=weights / weights.sum()))]
+
+
+def _steps(walker: AgentViewProtocol, cell: object, model: ModelViewProtocol) -> bool:
+    """Return whether a walker stepped in its activation, since it had not arrived at its goal before."""
+    del cell, model
+    return isinstance(walker, WalkerView) and not walker.arrived
+
+
+def _get_footprint(walker: AgentViewProtocol, cell: object, model: ModelViewProtocol) -> float:
+    """Return the footprint `intensity (1 - G / G_max)` a walker leaves on the ground of its cell."""
+    if not isinstance(walker, WalkerView):
+        return 0.0
+    return walker.intensity * (1 - model.field('target.G', cell) / walker.G_max)
+
+
+@register_model(
+    field='biology/collective_behaviour',
+    tags=('agents', 'field', 'trail formation', 'co-simulation'),
+    references=('Helbing, Keltsch, and Molnár 1997', 'arXiv:cond-mat/0012229'),
+    defaults={'until': 300, 'dt': 1},
+)
+def active_walkers(
+    size: int = 30,
+    *,
+    n_walkers: int = 20,
+    attraction: float = 1.0,
+    T: float = 200.0,
+    random_state: int | np.random.Generator | None = 0,
+) -> System:
+    """Return active walkers who walk between the corners of a green and wear a system of trails into it.
+
+    Walkers prefer existing trails to the direct way, and trails fade unless they are used, so a few shared trails
+    emerge that bundle the ways between the corners, a compromise between short and comfortable routes.
+
+    Args:
+        size:
+            The number of rows and columns of the green.
+
+        n_walkers:
+            The number of walkers.
+
+        attraction:
+            How strongly trails draw the walkers.
+
+        T:
+            The durability of trails.
+
+        random_state:
+            The seed or generator of the starting corners and goals.
+
+    Returns:
+        system:
+            The model, with the walkers `people/walkers`, the ground structure `land/ground.G`, and the trail potential
+            `land/ground.V`.
+
+    Examples:
+        >>> from skcomplex.models.biology.collective_behaviour import active_walkers
+        >>> [child.label for child in active_walkers().systems]
+        ['people', 'land']
+    """
+    rng = np.random.default_rng(random_state)
+    corners = _corners(size, size)
+    starts = rng.integers(len(corners), size=n_walkers)
+    goals = [corners[(start + 1 + int(rng.integers(len(corners) - 1))) % len(corners)] for start in starts]
+    walkers = GroupElement(
+        'walkers',
+        element=WalkerElement,
+        size=n_walkers,
+        values={
+            'goal_x': np.array([float(goal[0]) for goal in goals]),
+            'goal_y': np.array([float(goal[1]) for goal in goals]),
+            'attraction': attraction,
+            'width': float(size),
+            'height': float(size),
+        },
+        location=[corners[start] for start in starts],
+    )
+    ground = FieldElement(
+        'ground',
+        element=GroundElement,
+        space=LatticeSpace((size, size), boundary='reflecting'),
+        values={'T': T},
+    )
+    return System(
+        systems=[
+            System('people', elements=[walkers], space=LatticeSpace((size, size), boundary='fixed')),
+            System(
+                'land',
+                elements=[ground],
+                interactions=[
+                    RelaxationInteraction('fading', target='ground', state='G', time=_get_durability),
+                    DiffusionInteraction('spreading', target='ground', state='V', coefficient=_get_diffusion),
+                    RelaxationInteraction(
+                        'smoothing',
+                        target='ground',
+                        state='V',
+                        goal=_get_structure,
+                        time=_get_relaxation,
+                    ),
+                ],
+            ),
+        ],
+        interactions=[
+            MovementInteraction('walk', target='people/walkers', step=_get_step, condition=_walks, schedule='member'),
+            TransferInteraction(
+                'footprints',
+                source='people/walkers',
+                target='land/ground',
+                state=Source(),
+                into='G',
+                amount=_get_footprint,
+                pairing='site',
+                guard=_steps,
+                form='agent',
+                schedule='member',
+            ),
+            LifeCycleInteraction(
+                'renewal',
+                target='people/walkers',
+                death=_waits,
+                renew=True,
+                values=_get_goal,
+                schedule='member',
+            ),
+            MapInteraction(
+                'arrival',
+                target='people/walkers',
+                state='arrived',
+                function=_get_arrived,
+                form='agent',
+                schedule='member',
+            ),
+        ],
+    )

skcomplex/models/biology/collective_behaviour/_walker.py

@@ -0,0 +1,97 @@
+"""Pedestrian who walks toward a goal, drawn to existing trails, and leaves footprints that build them."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+from typing import Annotated
+
+from sage.all__sagemath_symbolics import oo
+from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
+from sage.sets.real_set import RealSet
+
+from ....core.elements import Element
+from ....specs import ParameterSpec, StateSpec, VisualSpec
+from ._walker_view import WalkerView
+
+
+class WalkerElement(Element):
+    """Pedestrian who walks toward a goal, drawn to existing trails, and leaves footprints that build them.
+
+    The walker heads along the unit vector toward its goal plus `attraction` times the gradient of the trail potential
+    `V`, after Helbing, Keltsch, and Molnár. Every step it moves to a neighbouring cell with a probability that grows
+    with `exp(directedness * cos angle)`, where the angle is between the step and the heading, and adds the footprint
+    `intensity (1 - G / G_max)` to the ground. The step after it arrives at its goal it leaves the green, and a new
+    walker enters there with another entry point as goal, drawn at random, a renewal in place. The model adds the
+    step, the footprint, the renewal, and the arrival as member interactions.
+
+    Args:
+        label:
+            The label of the agent or group.
+
+        visual:
+            How the element is drawn, or `None` for `default_visual_`.
+
+        goal_x:
+            The column of the goal.
+
+        goal_y:
+            The row of the goal.
+
+        arrived:
+            Whether the walker stood at its goal at the end of the previous step, 1 or 0.
+
+        directedness:
+            How strongly the walker heads for its goal.
+
+        attraction:
+            How strongly trails draw the walker.
+
+        intensity:
+            The footprint on bare ground.
+
+        G_max:
+            The largest ground structure.
+
+        width:
+            The number of columns of the grid.
+
+        height:
+            The number of rows of the grid.
+
+    Examples:
+        >>> from skcomplex.core.elements import GroupElement
+        >>> from skcomplex.models.biology.collective_behaviour import WalkerElement
+        >>> GroupElement('walkers', element=WalkerElement, size=4, location=(0, 0)).size
+        4
+    """
+
+    def __init__(
+        self,
+        label: str,
+        visual: VisualSpec | None = VisualSpec('agents', {'color_by': 'goal_x'}),
+        *,
+        goal_x: Annotated[float, StateSpec()] = 0.0,
+        goal_y: Annotated[float, StateSpec()] = 0.0,
+        arrived: Annotated[float, StateSpec(domain=FiniteEnumeratedSet([0, 1]))] = 0.0,
+        directedness: Annotated[float, ParameterSpec(domain=RealSet.closed_open(0, oo))] = 3.0,
+        attraction: Annotated[float, ParameterSpec(domain=RealSet.closed_open(0, oo))] = 1.0,
+        intensity: Annotated[float, ParameterSpec(domain=RealSet.closed_open(0, oo))] = 1.0,
+        G_max: Annotated[float, ParameterSpec(domain=RealSet.open(0, oo))] = 5.0,
+        width: Annotated[float, ParameterSpec(domain=RealSet.open(0, oo))] = 30.0,
+        height: Annotated[float, ParameterSpec(domain=RealSet.open(0, oo))] = 30.0,
+    ) -> None:
+        super().__init__(label, visual=visual)
+        self.goal_x = goal_x
+        self.goal_y = goal_y
+        self.arrived = arrived
+        self.directedness = directedness
+        self.attraction = attraction
+        self.intensity = intensity
+        self.G_max = G_max
+        self.width = width
+        self.height = height
+
+    @classmethod
+    def _get_view(cls) -> type[WalkerView]:
+        """Return the view of a walker, `WalkerView`."""
+        return WalkerView

skcomplex/models/biology/collective_behaviour/_walker_view.py

@@ -0,0 +1,23 @@
+"""View of a walker as its rules see it."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+from ....engine.solvers import AgentView
+
+
+class WalkerView(AgentView):
+    """View of a walker, with its states and parameters as attributes.
+
+    `WalkerElement` names this class with `_get_view`, so its rules read them with checked types.
+    """
+
+    goal_x: float
+    goal_y: float
+    arrived: float
+    directedness: float
+    attraction: float
+    intensity: float
+    G_max: float
+    width: float
+    height: float

skcomplex/models/biology/common/__init__.py

@@ -0,0 +1,3 @@
+"""Realizations shared by several biology packages: excitable kinetics, populations, networks, and stigmergy."""
+
+__all__: list[str] = []

skcomplex/models/biology/common/excitable/__init__.py

@@ -0,0 +1,7 @@
+"""Excitable kinetics shared by the biology packages: the FitzHugh-Nagumo fast-slow kinetics."""
+
+from ._fitzhugh_nagumo import FitzHughNagumoInteraction
+
+__all__: list[str] = [
+    'FitzHughNagumoInteraction',
+]

skcomplex/models/biology/common/excitable/_fitzhugh_nagumo.py

@@ -0,0 +1,121 @@
+"""Define FitzHugh-Nagumo kinetics, a fast variable with a cubic nullcline and a slow linear recovery."""
+
+# Author: Georgios Douzas <gdouzas@icloud.com>
+# License: MIT
+
+from types import SimpleNamespace
+from typing import Annotated
+
+from sage.all__sagemath_symbolics import oo
+from sage.sets.real_set import RealSet
+
+from .....core.interactions import Interaction
+from .....core.laws import BaseLaw, RateLaw
+from .....errors import ValidationError
+from .....specs import ParameterSpec, RoleSpec
+
+
+class FitzHughNagumoInteraction(Interaction):
+    """FitzHugh-Nagumo kinetics of a fast variable `v` and a slow recovery `w` of a target.
+
+    The fast variable follows `v' = v - v³/3 - w + I` and the recovery `w' = epsilon (v + a - b w)`. On a field the
+    kinetics act on every cell, and a diffusion of the fast variable makes the medium excitable.
+
+    Args:
+        label:
+            The label of the interaction.
+
+        target:
+            The path of the element or field whose states follow the kinetics.
+
+        fast:
+            The name of the fast state, such as a membrane potential.
+
+        slow:
+            The name of the slow recovery state.
+
+        a:
+            The offset of the recovery.
+
+        b:
+            The damping of the recovery.
+
+        epsilon:
+            The time scale of the recovery.
+
+        I:
+            The applied current.
+
+    Raises:
+        ValidationError:
+            A state name is not a name, or the fast and the slow state are the same.
+
+    Examples:
+        >>> from typing import Annotated
+        >>> from skcomplex.core.elements import Element
+        >>> from skcomplex.core.system import System
+        >>> from skcomplex.engine.runtime import Simulation
+        >>> from skcomplex.models.biology.common.excitable import FitzHughNagumoInteraction
+        >>> from skcomplex.specs import StateSpec
+        >>> class CellElement(Element):
+        ...     def __init__(
+        ...         self, label, visual=None, *, v: Annotated[float, StateSpec()] = -1.2,
+        ...         w: Annotated[float, StateSpec()] = -0.6,
+        ...     ):
+        ...         super().__init__(label, visual=visual)
+        ...         self.v = v
+        ...         self.w = w
+        >>> kinetics = FitzHughNagumoInteraction('kinetics', target='cell', I=0.5)
+        >>> system = System(elements=[CellElement('cell')], interactions=[kinetics])
+        >>> trajectory = Simulation(system, dt=0.1).check().prepare().run(until=100.0).trajectory_
+        >>> bool(trajectory.values('cell.v').max() > 1.5)
+        True
+    """
+
+    def __init__(
+        self,
+        label: str,
+        *,
+        target: Annotated[str, RoleSpec()],
+        fast: str = 'v',
+        slow: str = 'w',
+        a: Annotated[float, ParameterSpec()] = 0.7,
+        b: Annotated[float, ParameterSpec(domain=RealSet.closed_open(0, oo))] = 0.8,
+        epsilon: Annotated[float, ParameterSpec(domain=RealSet.open(0, oo))] = 0.08,
+        I: Annotated[float, ParameterSpec()] = 0.0,
+    ) -> None:
+        super().__init__(label)
+        self.target = target
+        self.fast = fast
+        self.slow = slow
+        self.a = a
+        self.b = b
+        self.epsilon = epsilon
+        self.I = I
+
+    def _check(self) -> None:
+        """Raise an error for state names that are not names or that coincide.
+
+        Raises:
+            ValidationError:
+                A state name is not a name, or the fast and the slow state are the same.
+        """
+        super()._check()
+        names = (self.fast, self.slow)
+        if not all(isinstance(name, str) and name.isidentifier() for name in names) or self.fast == self.slow:
+            error_msg = f'{self.label!r} reads the states {names!r}. Give two different names of states.'
+            raise ValidationError(error_msg)
+
+    def _get_laws(self, s: SimpleNamespace) -> list[BaseLaw]:
+        """Return the cubic fast kinetics and the slow linear recovery.
+
+        Args:
+            s:
+                The namespace of the symbols the laws can use, with the namespace of the target.
+
+        Returns:
+            laws:
+                The rate laws of the fast and the slow state.
+        """
+        v, w = getattr(s.target, self.fast), getattr(s.target, self.slow)
+        return [RateLaw(v, v - v**3 / 3 - w + s.I), RateLaw(w, s.epsilon * (v + s.a - s.b * w))]

skcomplex/models/biology/common/kinetics/__init__.py

@@ -0,0 +1,7 @@
+"""Reaction kinetics shared by the biology packages: reactions whose propensity saturates in their substrate."""
+
+from ._michaelis_menten import MichaelisMentenInteraction
+
+__all__: list[str] = [
+    'MichaelisMentenInteraction',
+]