From 24c59c3f086480c9960c207527269fff61ae13c9 Mon Sep 17 00:00:00 2001
From: fhchl <fhchl@users.noreply.github.com>
Date: Wed, 31 Jan 2024 10:38:42 +0100
Subject: [PATCH 01/10] WIP

---
 dynax/system.py       |  1 +
 tests/test_systems.py | 12 ++++++++++++
 2 files changed, 13 insertions(+)

diff --git a/dynax/system.py b/dynax/system.py
index 1082407..ba5960e 100644
--- a/dynax/system.py
+++ b/dynax/system.py
@@ -97,6 +97,7 @@ def output(self, x, u, t):
     # these attributes should be set by subclasses
     n_states: int | Literal["scalar"] = static_field(init=False)
     n_inputs: int | Literal["scalar"] = static_field(init=False)
+    initial_state: Array | None = static_field(default=None)
 
     def __check_init__(self):
         # Check that required attributes are initialized
diff --git a/tests/test_systems.py b/tests/test_systems.py
index cf4d407..3b13cf6 100644
--- a/tests/test_systems.py
+++ b/tests/test_systems.py
@@ -144,3 +144,15 @@ def test_discrete_forward_model():
     scipy_t, scipy_y, scipy_x = dlsim(scipy_sys, u, x0=x0, t=t)
     npt.assert_allclose(scipy_y, y, **tols)
     npt.assert_allclose(scipy_x, x, **tols)
+
+        
+def test_initial_state():
+    class Sys(DynamicalSystem):
+        n_states = "scalar"
+        n_inputs = "scalar"
+
+        def vector_field(self, x, u, t=None):
+            return x * 0.1 + u
+
+    Sys(initial_state=1)
+            

From 86129efe799135eff872707000fa79181fca2dc7 Mon Sep 17 00:00:00 2001
From: fhchl <fhchl@users.noreply.github.com>
Date: Wed, 31 Jan 2024 18:56:29 +0100
Subject: [PATCH 02/10] add cool ascii flow charts and work on system.py

---
 docs/conf.py             |   1 +
 dynax/estimation.py      |  22 +++-
 dynax/evolution.py       |  89 ++++++++-----
 dynax/example_models.py  |  18 ++-
 dynax/linearize.py       |  87 ++++++-------
 dynax/system.py          | 271 +++++++++++++++++++++++++--------------
 tests/test_estimation.py |  64 ++++-----
 tests/test_evolution.py  | 114 ++++++++++++++++
 tests/test_linearize.py  |  37 +++---
 tests/test_systems.py    | 126 ++----------------
 10 files changed, 474 insertions(+), 355 deletions(-)
 create mode 100644 tests/test_evolution.py

diff --git a/docs/conf.py b/docs/conf.py
index 3e263b5..f89159a 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -20,6 +20,7 @@
     "sphinx.ext.napoleon",
     "sphinx.ext.viewcode",
     "sphinxcontrib.bibtex",
+    "sphinxcontrib.aafig",
     "sphinx_autodoc_typehints",
     "nbsphinx",
 ]
diff --git a/dynax/estimation.py b/dynax/estimation.py
index b98818f..bc7d57d 100644
--- a/dynax/estimation.py
+++ b/dynax/estimation.py
@@ -150,7 +150,7 @@ def fit_least_squares(
     model: AbstractEvolution,
     t: ArrayLike,
     y: ArrayLike,
-    x0: ArrayLike,
+    x0: Optional[ArrayLike] = None,
     u: Optional[ArrayLike] = None,
     batched: bool = False,
     sigma: Optional[ArrayLike] = None,
@@ -168,7 +168,11 @@ def fit_least_squares(
     """
     t = jnp.asarray(t)
     y = jnp.asarray(y)
-    x0 = jnp.asarray(x0)
+
+    if x0 is not None:
+        x0 = jnp.asarray(x0)
+    else:
+        x0 = model.system.initial_state
 
     if batched:
         # First axis holds experiments, second axis holds time.
@@ -212,7 +216,7 @@ def residual_term(params):
             # this can use pmap, if batch size is smaller than CPU cores
             model = jax.vmap(model)
         # FIXME: ucoeffs not supported for Map
-        _, pred_y = model(x0, t=t, ucoeffs=ucoeffs)
+        _, pred_y = model(t=t, ucoeffs=ucoeffs, initial_state=x0)
         res = (y - pred_y) * weight
         return res.reshape(-1)
 
@@ -246,7 +250,7 @@ def fit_multiple_shooting(
     model: AbstractEvolution,
     t: ArrayLike,
     y: ArrayLike,
-    x0: ArrayLike,
+    x0: Optional[ArrayLike] = None,
     u: Optional[Union[Callable[[float], Array], ArrayLike]] = None,
     num_shots: int = 1,
     continuity_penalty: float = 0.1,
@@ -273,7 +277,11 @@ def fit_multiple_shooting(
     """
     t = jnp.asarray(t)
     y = jnp.asarray(y)
-    x0 = jnp.asarray(x0)
+
+    if x0 is not None:
+        x0 = jnp.asarray(x0)
+    else:
+        x0 = model.system.initial_state
 
     if u is None:
         msg = (
@@ -332,7 +340,7 @@ def fit_multiple_shooting(
     def residuals(params):
         x0s, model = unravel(params)
         x0s = jnp.concatenate((x0[None], x0s), axis=0)
-        xs_pred, ys_pred = jax.vmap(model)(x0s, t=ts0, ucoeffs=ucoeffs)
+        xs_pred, ys_pred = jax.vmap(model)(t=ts0, ucoeffs=ucoeffs, initial_state=x0s)
         # output residual
         res_y = ((ys - ys_pred) / std_y).reshape(-1)
         res_y = res_y / np.sqrt(len(res_y))
@@ -362,7 +370,7 @@ def transfer_function(sys: DynamicalSystem, to_states: bool = False, **kwargs):
 
     def H(s: complex):
         """Transfer-function at s."""
-        identity = np.eye(linsys.n_states)
+        identity = np.eye(linsys.initial_state.size)
         phi_B = jnp.linalg.solve(s * identity - A, B)
         if to_states:
             return phi_B
diff --git a/dynax/evolution.py b/dynax/evolution.py
index 31d61ee..20a8f70 100644
--- a/dynax/evolution.py
+++ b/dynax/evolution.py
@@ -1,56 +1,74 @@
-from typing import Callable, Optional
+from abc import abstractmethod
+from typing import Callable, cast, Optional
 
 import diffrax as dfx
 import equinox as eqx
 import jax
 import jax.numpy as jnp
-from jaxtyping import Array, ArrayLike, PyTree
+from jaxtyping import Array, PyTree
 
 from .interpolation import spline_it
 from .system import DynamicalSystem
 from .util import broadcast_right, dim2shape
 
 
+def check_shape(shape, dim, arg):
+    if not (dim == "scalar" and shape != ()) and not (shape[1:] == (dim,)):
+        raise ValueError(f"Argument {arg} of shape {shape} is size {dim}.")
+
+
 class AbstractEvolution(eqx.Module):
     """Abstract base-class for evolutions."""
 
-    def __call__(self, x0: ArrayLike, t: Array, u: Array, **kwargs):
-        raise NotImplementedError
+    system: DynamicalSystem
 
+    @abstractmethod
+    def __call__(
+        self, t: Array, u: Optional[Array], initial_state: Optional[Array]
+    ) -> tuple[Array, Array]:
+        """Evolve an initial state along the vector field and compute output.
 
-def check_shape(shape, dim, arg):
-    if not (dim == "scalar" and shape != ()) and not (shape[1:] == (dim,)):
-        raise ValueError(f"Argument {arg} of shape {shape} is size {dim}.")
+        Args:
+            t: The time periode over which to solve.
+            u: An optional input sequence of same length.
+            initial_state: An optional, fixed initial state used instead of
+                `system.initial_state`.
+
+        """
+        raise NotImplementedError
 
 
 class Flow(AbstractEvolution):
-    """Evolution function for continous-time dynamical system."""
+    """Evolution for continous-time dynamical systems."""
 
-    system: DynamicalSystem
     solver: dfx.AbstractAdaptiveSolver = eqx.static_field(default_factory=dfx.Dopri5)
     step: dfx.AbstractStepSizeController = eqx.static_field(
         default_factory=dfx.ConstantStepSize
-    )
+    )  # TODO: replace with adaptive step size
     dt0: Optional[float] = eqx.static_field(default=None)
 
     def __call__(
         self,
-        x0: ArrayLike,
         t: Array,
         u: Optional[Array] = None,
+        initial_state: Optional[Array] = None,
+        *,
         ufun: Optional[Callable[[float], Array]] = None,
         ucoeffs: Optional[tuple[PyTree, PyTree, PyTree, PyTree]] = None,
         **diffeqsolve_kwargs,
     ) -> tuple[Array, Array]:
         """Solve initial value problem for state and output trajectories."""
+        # Parse inputs.
         t = jnp.asarray(t)
-        x0 = jnp.asarray(x0)
 
-        # Check initial state shape
-        if x0.shape != dim2shape(self.system.n_states):
-            raise ValueError("Initial state dimenions do not match.")
+        if initial_state is not None:
+            x = jnp.asarray(initial_state)
+            if initial_state.shape != self.system.initial_state.shape:
+                raise ValueError("Initial state dimenions do not match.")
+        else:
+            initial_state = self.system.initial_state
 
-        # Prepare input function
+        # Prepare input function.
         if u is None and ufun is None and ucoeffs is None and self.system.n_inputs == 0:
             _ufun = lambda t: jnp.empty((0,))
         elif ucoeffs is not None:
@@ -66,7 +84,7 @@ def __call__(
         else:
             raise ValueError("Must specify one of u, ufun, or ucoeffs.")
 
-        # Check shape of ufun return values
+        # Check shape of ufun return values.
         out = jax.eval_shape(_ufun, 0.0)
         if not isinstance(out, jax.ShapeDtypeStruct):
             raise ValueError(f"ufun must return Arrays, not {type(out)}.")
@@ -74,12 +92,12 @@ def __call__(
             if not out.shape == dim2shape(self.system.n_inputs):
                 raise ValueError("Input dimensions do not match.")
 
-        # Solve ODE
+        # Solve ODE.
         diffeqsolve_default_options = dict(
             solver=self.solver,
             stepsize_controller=self.step,
             saveat=dfx.SaveAt(ts=t),
-            max_steps=50 * len(t),
+            max_steps=50 * len(t),  # completely arbitrary number of steps
             adjoint=dfx.DirectAdjoint(),
             dt0=self.dt0 if self.dt0 is not None else t[1],
         )
@@ -90,40 +108,46 @@ def __call__(
             term,
             t0=t[0],
             t1=t[-1],
-            y0=x0,
+            y0=initial_state,
             args=self,  # https://github.com/patrick-kidger/diffrax/issues/135
             **diffeqsolve_default_options,
         ).ys
+        # Could be in general a Pytree, but we only allow Array states.
+        x = cast(Array, x)
 
-        # Compute output
+        # Compute output.
         y = jax.vmap(self.system.output)(x, u, t)
 
         return x, y
 
 
 class Map(AbstractEvolution):
-    """Flow map for evolving a discrete-time dynamical system."""
-
-    system: DynamicalSystem
+    """Evolution for discrete-time dynamical systems."""
 
     def __call__(
         self,
-        x0: ArrayLike,
         t: Optional[Array] = None,
         u: Optional[Array] = None,
+        initial_state: Optional[Array] = None,
+        *,
         num_steps: Optional[int] = None,
-    ):
+    ) -> tuple[Array, Array]:
         """Solve discrete map."""
-        x0 = jnp.asarray(x0)
+
+        # Parse inputs.
+        if initial_state is not None:
+            x = jnp.asarray(initial_state)
+            if initial_state.shape != self.system.initial_state.shape:
+                raise ValueError("Initial state dimenions do not match.")
+        else:
+            initial_state = self.system.initial_state
 
         if t is not None:
             t = jnp.asarray(t)
-            num_steps = len(t)
         elif u is not None:
             u = jnp.asarray(u)
-            num_steps = len(u)
         elif num_steps is not None:
-            t = jnp.zeros(num_steps)
+            t = jnp.arange(num_steps)
         else:
             raise ValueError("must specify one of num_steps, t, or u.")
 
@@ -139,14 +163,15 @@ def __call__(
             inputs = u
             unpack = lambda input: (None, input)
 
+        # Evolve.
         def scan_fun(state, input):
             t, u = unpack(input)
             next_state = self.system.vector_field(state, u, t)
             return next_state, state
 
-        _, x = jax.lax.scan(scan_fun, x0, inputs, length=num_steps)
+        _, x = jax.lax.scan(scan_fun, initial_state, inputs, length=num_steps)
 
-        # Compute output
+        # Compute output.
         y = jax.vmap(self.system.output)(x, u, t)
 
         return x, y
diff --git a/dynax/example_models.py b/dynax/example_models.py
index f4fe6d9..df741d3 100644
--- a/dynax/example_models.py
+++ b/dynax/example_models.py
@@ -13,7 +13,8 @@ class PlasticFlowLinElastic(DynamicalSystem):
     kappa: float = non_negative_field()
     alpha: float
     sigma_0: float
-    n_states = 2
+
+    initial_state = jnp.zeros(2)
     n_inputs = "scalar"
 
     def vector_field(self, x, u, t=None):
@@ -41,7 +42,8 @@ class SpringMassDamper(DynamicalSystem):
     m: float
     r: float
     k: float
-    n_states = 2
+
+    initial_state = jnp.zeros(2)
     n_inputs = "scalar"
 
     def vector_field(self, x, u, t=None):
@@ -61,7 +63,8 @@ class NonlinearDrag(ControlAffine):
     k: float
     m: float
     outputs: list[int] = static_field(default_factory=lambda: [0])
-    n_states = 2
+
+    initial_state = jnp.zeros(2)
     n_inputs = "scalar"
 
     def f(self, x):
@@ -80,7 +83,7 @@ def h(self, x):
 class Sastry9_9(ControlAffine):
     """Sastry Example 9.9"""
 
-    n_states = 3
+    initial_state = jnp.zeros(3)
     n_inputs = "scalar"
 
     def f(self, x):
@@ -94,13 +97,14 @@ def h(self, x):
 
 
 class LotkaVolterra(DynamicalSystem):
-    n_states = 2
-    n_inputs = 0
     alpha: float = non_negative_field()
     beta: float = non_negative_field()
     gamma: float = non_negative_field()
     delta: float = non_negative_field()
 
+    initial_state = jnp.ones(2)
+    n_inputs = 0
+
     def vector_field(self, x, u=None, t=None):
         x, y = x
         return jnp.array(
@@ -118,6 +122,8 @@ class SpringMassWithBoucWenHysteresis(DynamicalSystem):
     n: float = non_negative_field(min_val=1.0)
     a: float = boxed_field(0.0, 1.0)
 
+    initial_state = jnp.zeros(3)
+
     def vector_field(self, x, u=None, t=None):
         if u is None:
             u = 0
diff --git a/dynax/linearize.py b/dynax/linearize.py
index bfb61d3..1335c6a 100644
--- a/dynax/linearize.py
+++ b/dynax/linearize.py
@@ -11,7 +11,13 @@
 from jaxtyping import Array
 
 from .derivative import lie_derivative
-from .system import ControlAffine, DynamicalSystem, LinearSystem
+from .system import (
+    _CoupledSystemMixin,
+    ControlAffine,
+    DynamicalSystem,
+    DynamicStateFeedbackSystem,
+    LinearSystem,
+)
 
 
 # TODO: make this a method of ControlAffine
@@ -211,39 +217,43 @@ def fn(u, args):
     return feedbacklaw
 
 
-class DiscreteLinearizingSystem(DynamicalSystem):
+class DiscreteLinearizingSystem(DynamicalSystem, _CoupledSystemMixin):
     r"""Dynamics computing linearizing feedback as output."""
 
-    sys: ControlAffine
-    refsys: LinearSystem
-    feedbacklaw: Callable
+    _v: Callable
 
     n_inputs = "scalar"
 
-    def __init__(self, sys, refsys, reldeg, linearizing_output=None):
+    def __init__(
+        self,
+        sys: ControlAffine,
+        refsys: LinearSystem,
+        reldeg: int,
+        **fb_kwargs,
+    ):
         if sys.n_inputs != "scalar":
             raise ValueError("Only single input systems supported.")
-        self.sys = sys
-        self.refsys = refsys
-        self.n_states = self.sys.n_states + self.refsys.n_states + 1
-        self.feedbacklaw = discrete_input_output_linearize(
-            sys, reldeg, refsys, linearizing_output
+        self._sys1 = sys
+        self._sys2 = refsys
+        self.initial_state = jnp.append(
+            self._pack_states(self._sys1.initial_state, self._sys2.initial_state), 0.0
         )
+        self._v = discrete_input_output_linearize(sys, reldeg, refsys, **fb_kwargs)
 
-    def vector_field(self, x, u, t=None):
-        x, z, v_last = x[: self.sys.n_states], x[self.sys.n_states : -1], x[-1]
-        v = self.feedbacklaw(x, z, u, v_last)
-        xn = self.sys.vector_field(x, v)
-        zn = self.refsys.vector_field(z, u)
-        return jnp.concatenate((xn, zn, jnp.array([v])))
-
-    def output(self, x, u, t=None):
-        x, z, v_last = x[: self.sys.n_states], x[self.sys.n_states : -1], x[-1]
-        v = self.feedbacklaw(x, z, u, v_last)  # FIXME: feedback law called twice
+    def vector_field(self, x, u=None, t=None):
+        (x, z), v_last = self._unpack_states(x[:-1]), x[-1]
+        v = self._v(x, z, u, v_last)
+        xn = self._sys1.vector_field(x, v)
+        zn = self._sys2.vector_field(z, u)
+        return jnp.append(self._pack_states(xn, zn), v)
+
+    def output(self, x, u=None, t=None):
+        (x, z), v_last = self._unpack_states(x[:-1]), x[-1]
+        v = self._v(x, z, u, v_last)  # FIXME: feedback law called twice
         return v
 
 
-class LinearizingSystem(DynamicalSystem):
+class LinearizingSystem(DynamicStateFeedbackSystem):
     r"""Coupled ODE of nonlinear dynamics, linear reference and io linearizing law.
 
     .. math::
@@ -259,10 +269,6 @@ class LinearizingSystem(DynamicalSystem):
 
     """
 
-    sys: ControlAffine
-    refsys: LinearSystem
-    feedbacklaw: Callable[[Array, Array, float], float]
-
     n_inputs = "scalar"
 
     def __init__(
@@ -270,29 +276,12 @@ def __init__(
         sys: ControlAffine,
         refsys: LinearSystem,
         reldeg: int,
-        feedbacklaw: Optional[Callable] = None,
-        linearizing_output: Optional[int] = None,
+        **fb_kwargs,
     ):
-        self.sys = sys
-        self.refsys = refsys
-        self.n_states = (
-            self.sys.n_states + self.refsys.n_states
-        )  # FIXME: support "scalar"
-        if callable(feedbacklaw):
-            self.feedbacklaw = feedbacklaw
-        else:
-            self.feedbacklaw = input_output_linearize(
-                sys, reldeg, refsys, linearizing_output
-            )
-
-    def vector_field(self, x, u=None, t=None):
-        x, z = x[: self.sys.n_states], x[self.sys.n_states :]
-        y = self.feedbacklaw(x, z, u)
-        dx = self.sys.vector_field(x, y)
-        dz = self.refsys.vector_field(z, u)
-        return jnp.concatenate((dx, dz))
+        v = input_output_linearize(sys, reldeg, refsys, **fb_kwargs)
+        super().__init__(sys, refsys, v)
 
     def output(self, x, u, t=None):
-        x, z = x[: self.sys.n_states], x[self.sys.n_states :]
-        ur = self.feedbacklaw(x, z, u)
-        return ur
+        x, z = self._unpack_states(x)
+        v = self._v(x, z, u)
+        return v
diff --git a/dynax/system.py b/dynax/system.py
index ba5960e..b127d21 100644
--- a/dynax/system.py
+++ b/dynax/system.py
@@ -1,5 +1,6 @@
 """Classes for representing dynamical systems."""
 
+from abc import abstractmethod
 from collections.abc import Callable
 from dataclasses import field
 from typing import Literal
@@ -63,6 +64,9 @@ def non_negative_field(min_val: float = 0.0, **kwargs):
     return boxed_field(lower=min_val, upper=np.inf, **kwargs)
 
 
+# TODO: make abstract
+
+
 class DynamicalSystem(eqx.Module):
     r"""A continous-time dynamical system.
 
@@ -94,48 +98,54 @@ def output(self, x, u, t):
 
     """
 
-    # these attributes should be set by subclasses
-    n_states: int | Literal["scalar"] = static_field(init=False)
+    initial_state: Array = static_field(init=False)
     n_inputs: int | Literal["scalar"] = static_field(init=False)
-    initial_state: Array | None = static_field(default=None)
 
     def __check_init__(self):
         # Check that required attributes are initialized
-        required_attrs = ["n_states", "n_inputs"]
+        required_attrs = ["initial_state", "n_inputs"]
         for attr in required_attrs:
             if not hasattr(self, attr):
                 raise AttributeError(f"Attribute '{attr}' not initialized.")
 
         # Check that vector_field returns Arrays or scalars and not PyTrees
-        x = jax.ShapeDtypeStruct(dim2shape(self.n_states), jnp.float64)
+        x = self.initial_state
         u = jax.ShapeDtypeStruct(dim2shape(self.n_inputs), jnp.float64)
-        t = 1.0
-        out = jax.eval_shape(self.vector_field, x, u, t)
-        if not isinstance(out, jax.ShapeDtypeStruct):
+        try:
+            dx = jax.eval_shape(self.vector_field, x, u, t=1.0)
+            y = jax.eval_shape(self.output, x, u, t=1.0)
+        except Exception as e:
+            raise ValueError(
+                "Can not evaluate output shapes. Check your definitions!"
+            ) from e
+        if not isinstance(dx, jax.ShapeDtypeStruct):
             raise ValueError(
-                f"vector_field must return arrays or scalars, not {type(out)}"
+                f"vector_field must return arrays or scalars, not {type(dx)}"
             )
+        if not isinstance(y, jax.ShapeDtypeStruct):
+            raise ValueError(f"outpuut must return arrays or scalars, not {type(y)}")
+
+    @abstractmethod
+    def vector_field(self, x, u=None, t=None) -> Array:
+        """Compute state derivative."""
+        raise NotImplementedError
+
+    def output(self, x, u=None, t=None) -> Array:
+        """Compute output."""
+        return x
 
     @property
     def n_outputs(self) -> int | Literal["scalar"]:
         # Compute output size
-        x = jax.ShapeDtypeStruct(dim2shape(self.n_states), jnp.float64)
+        x = self.initial_state
         u = jax.ShapeDtypeStruct(dim2shape(self.n_inputs), jnp.float64)
         y = jax.eval_shape(self.output, x, u, t=1.0)
         return "scalar" if y.ndim == 0 else y.shape[0]
 
-    def vector_field(self, x, u=None, t=None):
-        """Compute state derivative."""
-        raise NotImplementedError
-
-    def output(self, x, u=None, t=None):
-        """Compute output."""
-        return x
-
     def linearize(self, x0=None, u0=None, t=None) -> "LinearSystem":
         """Compute the approximate linearized system around a point."""
         if x0 is None:
-            x0 = jnp.zeros(dim2shape(self.n_states))
+            x0 = self.initial_state
         if u0 is None:
             u0 = jnp.zeros(dim2shape(self.n_inputs))
         A, B, C, D = _linearize(self.vector_field, self.output, x0, u0, t)
@@ -227,36 +237,40 @@ def __init__(self, A: ArrayLike, B: ArrayLike, C: ArrayLike, D: ArrayLike):
         self.C = jnp.array(C)
         self.D = jnp.array(D)
 
-        # Extract number of states and inputs from matrices
-        self.n_states = "scalar" if self.A.ndim == 0 else self.A.shape[0]
-        if self.n_states == "scalar":
+    @property
+    def initial_state(self) -> Array:  # type: ignore
+        return jnp.array(0) if self.A.ndim == 0 else jnp.zeros(self.A.shape[0])
+
+    @property
+    def n_inputs(self) -> int | Literal["scalar"]:  # type: ignore
+        if self.initial_state.ndim == 0:
             if self.B.ndim == 0:
-                self.n_inputs = "scalar"
+                return "scalar"
             elif self.B.ndim == 1:
-                self.n_inputs = self.B.size
-            else:
-                raise ValueError("Dimension mismatch.")
+                return self.B.size
         else:
             if self.B.ndim == 1:
-                self.n_inputs = "scalar"
+                return "scalar"
             elif self.B.ndim == 2:
-                self.n_inputs = self.B.shape[1]
-            else:
-                raise ValueError("Dimension mismatch.")
+                return self.B.shape[1]
+        raise ValueError("Dimension mismatch.")
 
-    def vector_field(self, x, u=None, t=None):
+    def vector_field(self, x, u=None, t=None) -> Array:
         out = self.A.dot(x)
         if u is not None:
             out += self.B.dot(u)
         return out
 
-    def output(self, x, u=None, t=None):
+    def output(self, x, u=None, t=None) -> Array:
         out = self.C.dot(x)
         if u is not None:
             out += self.D.dot(u)
         return out
 
 
+# TODO: make abstract
+
+
 class ControlAffine(DynamicalSystem):
     r"""A control-affine dynamical system.
 
@@ -276,7 +290,6 @@ def g(self, x):
     def h(self, x):
         return x
 
-    # FIXME: remove time dependence
     def vector_field(self, x, u=None, t=None):
         if u is None:
             u = 0
@@ -286,73 +299,122 @@ def output(self, x, u=None, t=None):
         return self.h(x)
 
 
-class SeriesSystem(DynamicalSystem):
-    """Two systems in series."""
-
+class _CoupledSystemMixin(eqx.Module):
     _sys1: DynamicalSystem
     _sys2: DynamicalSystem
 
+    def _pack_states(self, x1, x2) -> Array:
+        return jnp.concatenate(
+            (
+                jnp.atleast_1d(x1),
+                jnp.atleast_1d(x2),
+            )
+        )
+
+    def _unpack_states(self, x):
+        sys1_size = (
+            1
+            if jnp.ndim(self._sys1.initial_state) == 0
+            else self._sys1.initial_state.size
+        )
+        return (
+            x[:sys1_size].reshape(self._sys1.initial_state.shape),
+            x[sys1_size:].reshape(self._sys2.initial_state.shape),
+        )
+
+
+class SeriesSystem(DynamicalSystem, _CoupledSystemMixin):
+    r"""Two systems in series.
+
+    .. math::
+
+        ẋ_1 &= f_1(x_1, u, t)   \\
+        y_1 &= h_1(x_1, u, t)   \\
+        ẋ_2 &= f_2(x_2, y1, t)  \\
+        y_2 &= h_2(x_2, y1, t)
+
+    .. aafig::
+    
+               +------+      +------+
+        u --+->+ sys1 +--y1->+ sys2 +--> y2
+               +------+      +------+
+
+    """
+
     def __init__(self, sys1: DynamicalSystem, sys2: DynamicalSystem):
         """
         Args:
             sys1: system with n outputs
             sys2: system with n inputs
+
         """
-        assert sys1.n_outputs == sys2.n_inputs, "in- and outputs don't match"
         self._sys1 = sys1
         self._sys2 = sys2
-        self.n_states = sys1.n_states + sys2.n_states
+        self.initial_state = self._pack_states(sys1.initial_state, sys2.initial_state)
         self.n_inputs = sys1.n_inputs
 
     def vector_field(self, x, u=None, t=None):
-        x1 = x[: self._sys1.n_states]
-        x2 = x[self._sys1.n_states :]
+        x1, x2 = self._unpack_states(x)
         y1 = self._sys1.output(x1, u, t)
         dx1 = self._sys1.vector_field(x1, u, t)
         dx2 = self._sys2.vector_field(x2, y1, t)
-        return jnp.concatenate((jnp.atleast_1d(dx1), jnp.atleast_1d(dx2)))
+        return self._pack_states(dx1, dx2)
 
     def output(self, x, u=None, t=None):
-        x1 = x[: self._sys1.n_states]
-        x2 = x[self._sys1.n_states :]
+        x1, x2 = self._unpack_states(x)
         y1 = self._sys1.output(x1, u, t)
         y2 = self._sys2.output(x2, y1, t)
         return y2
 
 
-class FeedbackSystem(DynamicalSystem):
-    """Two systems connected via feedback."""
+class FeedbackSystem(DynamicalSystem, _CoupledSystemMixin):
+    r"""Two systems connected via feedback.
+    
+    .. math::
 
-    _sys: DynamicalSystem
-    _fbsys: DynamicalSystem
+        ẋ_1 &= f_1(x_1, u + y_2, t) \\
+        y_1 &= h_1(x_1, t)          \\
+        ẋ_2 &= f_2(x_2, y_1, t)     \\
+        y_2 &= h_2(x_2, y_1, t)     \\
+
+    .. aafig::
+    
+               +------+
+        u --+->+ sys1 +--+-> y1
+            ^  +------+  |
+            |            |
+          y2|  +------+  |
+            +--+ sys2 |<-+
+               +------+
 
-    def __init__(self, sys: DynamicalSystem, fbsys: DynamicalSystem):
+    """
+
+    def __init__(self, sys1: DynamicalSystem, sys2: DynamicalSystem):
         """
         Args:
-            sys: system in forward path
-            fbsys: system in feedback path
+            sys1: system in forward path with n inputs
+            sys2: system in feedback path with n outputs
 
         """
-        self._sys = sys
-        self._fbsys = fbsys
-        self.n_states = sys.n_states + fbsys.n_states
-        self.n_inputs = sys.n_inputs
+        self._sys1 = sys1
+        self._sys2 = sys2
+        self.initial_state = self._pack_states(sys1.initial_state, sys2.initial_state)
+        self.n_inputs = sys1.n_inputs
 
     def vector_field(self, x, u=None, t=None):
         if u is None:
-            u = np.zeros(self._sys.n_inputs)
-        x1 = x[: self._sys.n_states]
-        x2 = x[self._sys.n_states :]
-        y1 = self._sys.output(x1, None, t)
-        y2 = self._fbsys.output(x2, y1, t)
-        dx1 = self._sys.vector_field(x1, u + y2, t)
-        dx2 = self._fbsys.vector_field(x2, y1, t)
-        dx = jnp.concatenate((jnp.atleast_1d(dx1), jnp.atleast_1d(dx2)))
+            u = np.zeros(dim2shape(self._sys1.n_inputs))
+        x1, x2 = self._unpack_states(x)
+        y1 = self._sys1.output(x1, None, t)
+        y2 = self._sys2.output(x2, y1, t)
+        dx1 = self._sys1.vector_field(x1, u + y2, t)
+        dx2 = self._sys2.vector_field(x2, y1, t)
+        dx = self._pack_states(dx1, dx2)
         return dx
 
     def output(self, x, u=None, t=None):
-        x1 = x[: self._sys.n_states]
-        y = self._sys.output(x1, None, t)
+        x1, _ = self._unpack_states(x)
+        y = self._sys1.output(x1, None, t)
         return y
 
 
@@ -361,15 +423,26 @@ class StaticStateFeedbackSystem(DynamicalSystem):
 
     .. math::
 
-        ẋ &= f(x, v(x, u), t) \\
+        ẋ &= f(x, v(x), t) \\
         y &= h(x, u, t)
 
+    .. aafig::
+    
+                           +-----+
+        u --+------------->+ sys +----> y
+            ^              +--+--+  
+            |                 | 
+            |                 | x   
+            |  +--------+     |
+            +--+ "v(x)" +<----+
+               +--------+
+
     """
 
     _sys: DynamicalSystem
-    _feedbacklaw: Callable
+    _v: Callable[[Array], Array]
 
-    def __init__(self, sys: DynamicalSystem, v: Callable[[Array, Array], Array]):
+    def __init__(self, sys: DynamicalSystem, v: Callable[[Array], Array]):
         """
         Args:
             sys: system with vector field `f` and output `h`
@@ -377,14 +450,12 @@ def __init__(self, sys: DynamicalSystem, v: Callable[[Array, Array], Array]):
 
         """
         self._sys = sys
-        self._feedbacklaw = staticmethod(v)
-        self.n_states = sys.n_states
+        self._v = staticmethod(v)
+        self.initial_state = sys.initial_state
         self.n_inputs = sys.n_inputs
 
     def vector_field(self, x, u=None, t=None):
-        if u is None:
-            u = np.zeros(self._sys.n_inputs)
-        v = self._feedbacklaw(x, u)
+        v = self._v(x)
         dx = self._sys.vector_field(x, v, t)
         return dx
 
@@ -393,50 +464,60 @@ def output(self, x, u=None, t=None):
         return y
 
 
-class DynamicStateFeedbackSystem(DynamicalSystem):
+class DynamicStateFeedbackSystem(DynamicalSystem, _CoupledSystemMixin):
     r"""System with dynamic state-feedback.
 
     .. math::
+    
+        ẋ_1 &= f_1(x_1, v(x_1, x_2, u), t) \\
+        ẋ_2 &= f_2(x_2, u, t)              \\
+        y   &= h_1(x_1, u, t)
 
-        ẋ &= f_1(x, v(x, z, u), t) \\
-        ż &= f_2(z, r, t) \\
-        y &= h_1(x, u, t)
+    .. aafig::
+    
+              +--------------+     +-----+
+        u -+->+ v(x1, x2, u) +--v->+ sys +-> y
+           |  +-+-------+----+     +--+--+   
+           |    ^       ^             |
+           |    | x2    |      x1     |
+           |    |       +-------------+
+           |  +------+              
+           +->+ sys2 |                   
+              +------+     
 
     """
 
-    _sys: DynamicalSystem
-    _sys2: DynamicalSystem
-    _feedbacklaw: Callable[[Array, Array, float], float]
+    _v: Callable[[Array, Array, float], float]
 
     def __init__(
         self,
-        sys: DynamicalSystem,
+        sys1: DynamicalSystem,
         sys2: DynamicalSystem,
-        v: Callable[[Array, Array, float], float],
+        v: Callable[[Array, Array, Array | float], float],
     ):
         r"""
         Args:
-            sys: system with vector field :math:`f_1` and output :math:`h`
+            sys1: system with vector field :math:`f_1` and output :math:`h`
             sys2: system with vector field :math:`f_2`
             v: dynamic feedback law :math:`v`
 
         """
-        self._sys = sys
+        self._sys1 = sys1
         self._sys2 = sys2
-        self._feedbacklaw = v
-        self.n_states = sys.n_states + sys2.n_states
-        self.n_inputs = sys.n_inputs
+        self._v = staticmethod(v)
+        self.initial_state = self._pack_states(sys1.initial_state, sys2.initial_state)
+        self.n_inputs = sys1.n_inputs
 
-    def vector_field(self, xz, u=None, t=None):
+    def vector_field(self, x, u=None, t=None):
         if u is None:
-            u = np.zeros(self._sys.n_inputs)
-        x, z = xz[: self._sys.n_states], xz[self._sys.n_states :]
-        v = self._feedbacklaw(x, z, u)
-        dx = self._sys.vector_field(x, v, t)
-        dz = self._sys2.vector_field(z, u, t)
+            u = np.zeros(dim2shape(self._sys1.n_inputs))
+        x1, x2 = self._unpack_states(x)
+        v = self._v(x1, x2, u)
+        dx = self._sys1.vector_field(x1, v, t)
+        dz = self._sys2.vector_field(x2, u, t)
         return jnp.concatenate((dx, dz))
 
-    def output(self, xz, u=None, t=None):
-        x = xz[: self._sys.n_states]
-        y = self._sys.output(x, u, t)
+    def output(self, x, u=None, t=None):
+        x1, _ = self._unpack_states(x)
+        y = self._sys1.output(x1, u, t)
         return y
diff --git a/tests/test_estimation.py b/tests/test_estimation.py
index 979312b..5197bc2 100644
--- a/tests/test_estimation.py
+++ b/tests/test_estimation.py
@@ -31,14 +31,14 @@ def test_fit_least_squares(outputs):
         + np.sin(0.1 * 2 * np.pi * t)
         + np.sin(10 * 2 * np.pi * t)
     )
-    x0 = [1.0, 0.0]
+    x0 = jnp.array([1.0, 0.0])
     true_model = Flow(NonlinearDrag(1.0, 2.0, 3.0, 4.0, outputs))
-    _, y_true = true_model(x0, t, u)
+    _, y_true = true_model(t, u, x0)
     # fit
     init_model = Flow(NonlinearDrag(1.0, 1.0, 1.0, 1.0, outputs))
     pred_model = fit_least_squares(init_model, t, y_true, x0, u).result
     # check result
-    _, y_pred = pred_model(x0, t, u)
+    _, y_pred = pred_model(t, u, x0)
     npt.assert_allclose(y_pred, y_true, **tols)
     npt.assert_allclose(
         jax.tree_util.tree_flatten(pred_model)[0],
@@ -62,12 +62,12 @@ def test_fit_least_squares_on_batch():
     x0s = np.repeat(x0[None], us.shape[0], axis=0)
     ts = np.repeat(t[None], us.shape[0], axis=0)
     true_model = Flow(NonlinearDrag(1.0, 2.0, 3.0, 4.0))
-    _, ys = jax.vmap(true_model)(x0s, ts, us)
+    _, ys = jax.vmap(true_model)(ts, us, x0s)
     # fit
     init_model = Flow(NonlinearDrag(1.0, 1.0, 1.0, 1.0))
     pred_model = fit_least_squares(init_model, ts, ys, x0s, us, batched=True).result
     # check result
-    _, ys_pred = jax.vmap(pred_model)(x0s, ts, us)
+    _, ys_pred = jax.vmap(pred_model)(ts, us, x0s)
     npt.assert_allclose(ys_pred, ys, **tols)
     npt.assert_allclose(
         jax.tree_util.tree_flatten(pred_model)[0],
@@ -84,7 +84,7 @@ def test_can_compute_jacfwd_with_implicit_methods():
 
     def fun(m, r, k, x0=x0, solver_opt=solver_opt, t=t):
         model = Flow(SpringMassDamper(m, r, k), **solver_opt)
-        x_true, _ = model(x0, t, u=np.zeros_like(t))
+        x_true, _ = model(t, u=jnp.zeros_like(t), initial_state=x0)
         return x_true
 
     jac = jax.jacfwd(fun, argnums=(0, 1, 2))
@@ -93,20 +93,20 @@ def fun(m, r, k, x0=x0, solver_opt=solver_opt, t=t):
 
 def test_fit_with_bounded_parameters():
     # data
-    t = np.linspace(0, 1, 100)
-    x0 = [0.5, 0.5]
+    t = jnp.linspace(0, 1, 100)
+    x0 = jnp.array([0.5, 0.5])
     solver_opt = dict(step=PIDController(rtol=1e-5, atol=1e-7))
     true_model = Flow(
         LotkaVolterra(alpha=2 / 3, beta=4 / 3, gamma=1.0, delta=1.0), **solver_opt
     )
-    x_true, _ = true_model(x0, t)
+    x_true, _ = true_model(t, initial_state=x0)
     # fit
     init_model = Flow(
         LotkaVolterra(alpha=1.0, beta=1.0, gamma=1.5, delta=2.0), **solver_opt
     )
     pred_model = fit_least_squares(init_model, t, x_true, x0).result
     # check result
-    x_pred, _ = pred_model(x0, t)
+    x_pred, _ = pred_model(t, initial_state=x0)
     npt.assert_allclose(x_pred, x_true, **tols)
     npt.assert_allclose(
         jax.tree_util.tree_flatten(pred_model)[0],
@@ -117,11 +117,12 @@ def test_fit_with_bounded_parameters():
 
 def test_fit_with_bounded_parameters_and_ndarrays():
     # model
-    class LotkaVolterra(DynamicalSystem):
+    class LotkaVolterraBounded(DynamicalSystem):
         alpha: float
         beta: float
         delta_gamma: Array = non_negative_field()
-        n_states = 2
+
+        initial_state = jnp.array((0.5, 0.5))
         n_inputs = 0
 
         def vector_field(self, x, u=None, t=None):
@@ -132,22 +133,23 @@ def vector_field(self, x, u=None, t=None):
             )
 
     # data
-    t = np.linspace(0, 1, 100)
-    x0 = [0.5, 0.5]
+    t = jnp.linspace(0, 1, 100)
     solver_opt = dict(step=PIDController(rtol=1e-5, atol=1e-7))
     true_model = Flow(
-        LotkaVolterra(alpha=2 / 3, beta=4 / 3, delta_gamma=jnp.array([1.0, 1.0])),
+        LotkaVolterraBounded(
+            alpha=2 / 3, beta=4 / 3, delta_gamma=jnp.array([1.0, 1.0])
+        ),
         **solver_opt,
     )
-    x_true, _ = true_model(x0, t)
+    x_true, _ = true_model(t)
     # fit
     init_model = Flow(
-        LotkaVolterra(alpha=1.0, beta=1.0, delta_gamma=jnp.array([1.5, 2])),
+        LotkaVolterraBounded(alpha=1.0, beta=1.0, delta_gamma=jnp.array([1.5, 2])),
         **solver_opt,
     )
-    pred_model = fit_least_squares(init_model, t, x_true, x0).result
+    pred_model = fit_least_squares(init_model, t, x_true).result
     # check result
-    x_pred, _ = pred_model(x0, t)
+    x_pred, _ = pred_model(t)
     npt.assert_allclose(x_pred, x_true, **tols)
     npt.assert_allclose(
         ravel_pytree(pred_model)[0], ravel_pytree(true_model)[0], **tols
@@ -157,11 +159,11 @@ def vector_field(self, x, u=None, t=None):
 @pytest.mark.parametrize("num_shots", [1, 2, 3])
 def test_fit_multiple_shooting_with_input(num_shots):
     # data
-    t = np.linspace(0, 10, 10000)
-    u = np.sin(1 * 2 * np.pi * t)
-    x0 = [1.0, 0.0]
+    t = jnp.linspace(0, 10, 10000)
+    u = jnp.sin(1 * 2 * np.pi * t)
+    x0 = jnp.array([1.0, 0.0])
     true_model = Flow(SpringMassDamper(1.0, 2.0, 3.0))
-    x_true, _ = true_model(x0, t, u)
+    x_true, _ = true_model(t, u, initial_state=x0)
     # fit
     init_model = Flow(SpringMassDamper(1.0, 1.0, 1.0))
     pred_model = fit_multiple_shooting(
@@ -175,7 +177,7 @@ def test_fit_multiple_shooting_with_input(num_shots):
         verbose=2,
     ).result
     # check result
-    x_pred, _ = pred_model(x0, t, u)
+    x_pred, _ = pred_model(t, u, initial_state=x0)
     npt.assert_allclose(x_pred, x_true, **tols)
     npt.assert_allclose(
         jax.tree_util.tree_flatten(pred_model)[0],
@@ -187,13 +189,13 @@ def test_fit_multiple_shooting_with_input(num_shots):
 @pytest.mark.parametrize("num_shots", [1, 2, 3])
 def test_fit_multiple_shooting_without_input(num_shots):
     # data
-    t = np.linspace(0, 1, 1000)
-    x0 = [0.5, 0.5]
+    t = jnp.linspace(0, 1, 1000)
+    x0 = jnp.array([0.5, 0.5])
     solver_opt = dict(step=PIDController(rtol=1e-3, atol=1e-6))
     true_model = Flow(
         LotkaVolterra(alpha=2 / 3, beta=4 / 3, gamma=1.0, delta=1.0), **solver_opt
     )
-    x_true, _ = true_model(x0, t)
+    x_true, _ = true_model(t, initial_state=x0)
     # fit
     init_model = Flow(
         LotkaVolterra(alpha=1.0, beta=1.0, gamma=1.5, delta=2.0), **solver_opt
@@ -202,7 +204,7 @@ def test_fit_multiple_shooting_without_input(num_shots):
         init_model, t, x_true, x0, num_shots=num_shots, continuity_penalty=1
     ).result
     # check result
-    x_pred, _ = pred_model(x0, t)
+    x_pred, _ = pred_model(t, initial_state=x0)
     npt.assert_allclose(x_pred, x_true, atol=1e-3, rtol=1e-3)
     npt.assert_allclose(
         jax.tree_util.tree_flatten(pred_model)[0],
@@ -215,7 +217,7 @@ def test_fit_multiple_shooting_without_input(num_shots):
 def test_transfer_function():
     sys = SpringMassDamper(1.0, 1.0, 1.0)
     sr = 100
-    f = np.linspace(0, sr / 2, 100)
+    f = jnp.linspace(0, sr / 2, 100)
     s = 2 * np.pi * f * 1j
     H = jax.vmap(transfer_function(sys))(s)[:, 0]
     H_true = 1 / (sys.m * s**2 + sys.r * s + sys.k)
@@ -227,14 +229,14 @@ def test_csd_matching():
     # model
     sys = SpringMassDamper(1.0, 1.0, 1.0)
     model = Flow(sys, step=PIDController(rtol=1e-4, atol=1e-6))
-    x0 = np.zeros(sys.n_states)
+    x0 = np.zeros(jnp.shape(sys.initial_state))
     # input
     duration = 1000
     sr = 50
     t = np.arange(int(duration * sr)) / sr
     u = np.random.normal(size=len(t))
     # output
-    _, y = model(x0, t, u)
+    _, y = model(t, u, initial_state=x0)
     # fit
     init_sys = SpringMassDamper(1.0, 1.0, 1.0)
     fitted_sys = fit_csd_matching(init_sys, u, y, sr, nperseg=1024, verbose=1).result
diff --git a/tests/test_evolution.py b/tests/test_evolution.py
new file mode 100644
index 0000000..98ea8fd
--- /dev/null
+++ b/tests/test_evolution.py
@@ -0,0 +1,114 @@
+import diffrax as dfx
+import jax.numpy as jnp
+import numpy as np
+import numpy.testing as npt
+from scipy.signal import dlsim, dlti
+
+from dynax import DynamicalSystem, Flow, LinearSystem, Map
+
+
+tols = dict(rtol=1e-04, atol=1e-06)
+
+
+class SecondOrder(DynamicalSystem):
+    """Second-order, linear system with constant coefficients."""
+
+    b: float
+    c: float
+
+    n_inputs = 0
+    initial_state = jnp.array([0.0, 0.0])
+
+    def vector_field(self, x, u=None, t=None):
+        """ddx + b dx + c x = u as first order with x1=x and x2=dx."""
+        x1, x2 = x
+        dx1 = x2
+        dx2 = -self.b * x2 - self.c * x1
+        return jnp.array([dx1, dx2])
+
+    def output(self, x, u=None, t=None):
+        x1, _ = x
+        return x1
+
+
+def test_forward_model_crit_damp():
+    b = 2
+    c = 1  # critical damping as b**2 == 4*c
+    sys = SecondOrder(b, c)
+
+    def x(t, x0, dx0):
+        """Solution to critically damped linear second-order system."""
+        C2 = x0
+        C1 = b / 2 * C2
+        return np.exp(-b * t / 2) * (C1 * t + C2)
+
+    x0 = jnp.array([1, 0])  # x(t=0)=1, dx(t=0)=0
+    t = jnp.linspace(0, 1)
+    model = Flow(sys, step=dfx.PIDController(rtol=1e-7, atol=1e-9))
+    x_pred = model(t, initial_state=x0)[1]
+    x_true = x(t, *x0)
+    assert np.allclose(x_true, x_pred)
+
+
+def test_forward_model_lin_sys():
+    b = 2
+    c = 1  # critical damping as b**2 == 4*c
+    uconst = 1
+
+    A = jnp.array([[0, 1], [-c, -b]])
+    B = jnp.array([[0], [1]])
+    C = jnp.array([[1, 0]])
+    D = jnp.zeros((1, 1))
+    sys = LinearSystem(A, B, C, D)
+
+    def x(t, x0, dx0, uconst):
+        """Solution to critically damped linear second-order system."""
+        C2 = x0 - uconst / c
+        C1 = b / 2 * C2
+        return np.exp(-b * t / 2) * (C1 * t + C2) + uconst / c
+
+    x0 = jnp.array([1, 0])  # x(t=0)=1, dx(t=0)=0
+    t = jnp.linspace(0, 1)
+    u = jnp.ones(t.shape + (1,)) * uconst
+    model = Flow(sys, step=dfx.PIDController(rtol=1e-7, atol=1e-9))
+    x_pred = model(t, u, initial_state=x0)[1]
+    x_true = x(t, x0[0], x0[1], uconst)
+    assert np.allclose(x_true, x_pred)
+
+
+def test_discrete_forward_model():
+    b = 2
+    c = 1  # critical damping as b**2 == 4*c
+    t = jnp.arange(50)
+    u = jnp.sin(1 / len(t) * 2 * np.pi * t)[:, None]  # single input
+    x0 = jnp.array([1.0, 0.0])
+    A = jnp.array([[0, 1], [-c, -b]])
+    B = jnp.array([[0], [1]])
+    C = jnp.array([[1, 0]])
+    D = jnp.zeros((1, 1))
+    # test just input
+    sys = LinearSystem(A, B, C, D)
+    model = Map(sys)
+    x, y = model(u=u, initial_state=x0)  # ours
+    scipy_sys = dlti(A, B, C, D)
+    _, scipy_y, scipy_x = dlsim(scipy_sys, u, x0=x0)
+    npt.assert_allclose(scipy_y, y, **tols)
+    npt.assert_allclose(scipy_x, x, **tols)
+    # test input and time (results should be same)
+    x, y = model(u=u, t=t, initial_state=x0)
+    scipy_t, scipy_y, scipy_x = dlsim(scipy_sys, u, x0=x0, t=t)
+    npt.assert_allclose(scipy_y, y, **tols)
+    npt.assert_allclose(scipy_x, x, **tols)
+
+
+def test_initial_state():
+    class Sys(DynamicalSystem):
+        n_inputs = "scalar"
+        initial_state = jnp.array(1.0)
+
+        def vector_field(self, x, u, t=None):
+            return x * 0.1 + u
+
+    t = jnp.arange(5)
+    u = jnp.zeros(5)
+    x, y = Flow(Sys())(t, u)
diff --git a/tests/test_linearize.py b/tests/test_linearize.py
index feb3dec..df146be 100644
--- a/tests/test_linearize.py
+++ b/tests/test_linearize.py
@@ -28,7 +28,8 @@ class SpringMassDamperWithOutput(ControlAffine):
     r: float = 0.1
     k: float = 0.1
     out: int = 0
-    n_states = 2
+
+    initial_state = jnp.zeros(2)
     n_inputs = "scalar"
 
     def f(self, x):
@@ -92,7 +93,7 @@ def test_linearize_lin2lin():
 
 def test_linearize_dyn2lin():
     class ScalarScalar(DynamicalSystem):
-        n_states = "scalar"
+        initial_state = jnp.array(0.0)
         n_inputs = "scalar"
 
         def vector_field(self, x, u, t):
@@ -123,15 +124,15 @@ def test_input_output_linearize_single_output():
     """Feedback linearized system equals system linearized around x0."""
     sys = NonlinearDrag(0.1, 0.1, 0.1, 0.1)
     ref = sys.linearize()
-    xs = np.random.normal(size=(100, sys.n_states))
+    xs = np.random.normal(size=(100,) + sys.initial_state.shape)
     reldeg = relative_degree(sys, xs)
     feedbacklaw = input_output_linearize(sys, reldeg, ref)
     feedback_sys = DynamicStateFeedbackSystem(sys, ref, feedbacklaw)
-    t = np.linspace(0, 0.1)
-    u = np.sin(t)
+    t = jnp.linspace(0, 0.1)
+    u = jnp.sin(t)
     npt.assert_allclose(
-        Flow(ref)(np.zeros(sys.n_states), t, u)[1],
-        Flow(feedback_sys)(np.zeros(feedback_sys.n_states), t, u)[1],
+        Flow(ref)(t, u)[1],
+        Flow(feedback_sys)(t, u)[1],
         **tols,
     )
 
@@ -142,19 +143,19 @@ def test_input_output_linearize_multiple_outputs():
     ref = sys.linearize()
     for out_idx in range(2):
         out_idx = 1
-        xs = np.random.normal(size=(100, sys.n_states))
+        xs = np.random.normal(size=(100,) + sys.initial_state.shape)
         reldeg = relative_degree(sys, xs, output=out_idx)
         feedbacklaw = input_output_linearize(sys, reldeg, ref, output=out_idx)
         feedback_sys = DynamicStateFeedbackSystem(sys, ref, feedbacklaw)
-        t = np.linspace(0, 1)
-        u = np.sin(t) * 0.1
-        y_ref = Flow(ref)(np.zeros(sys.n_states), t, u)[1]
-        y = Flow(feedback_sys)(np.zeros(feedback_sys.n_states), t, u)[1]
+        t = jnp.linspace(0, 1)
+        u = jnp.sin(t) * 0.1
+        y_ref = Flow(ref)(t, u)[1]
+        y = Flow(feedback_sys)(t, u)[1]
         npt.assert_allclose(y_ref[:, out_idx], y[:, out_idx], **tols)
 
 
 class Lee7_4_5(DynamicalSystem):
-    n_states = 2
+    initial_state = jnp.zeros(2)
     n_inputs = "scalar"
 
     def vector_field(self, x, u, t=None):
@@ -174,10 +175,10 @@ def test_discrete_input_output_linearize():
     assert reldeg == 2
 
     feedback_sys = DiscreteLinearizingSystem(sys, refsys, reldeg)
-    t = np.linspace(0, 0.001, 10)
-    u = np.cos(t) * 0.1
-    _, v = Map(feedback_sys)(np.zeros(2 + 2 + 1), t, u)
-    _, y = Map(sys)(np.zeros(2), t, u)
-    _, y_ref = Map(refsys)(np.zeros(2), t, u)
+    t = jnp.linspace(0, 0.001, 10)
+    u = jnp.cos(t) * 0.1
+    _, v = Map(feedback_sys)(t, u)
+    _, y = Map(sys)(t, u)
+    _, y_ref = Map(refsys)(t, u)
 
     npt.assert_allclose(y_ref, y, **tols)
diff --git a/tests/test_systems.py b/tests/test_systems.py
index 3b13cf6..5c410bf 100644
--- a/tests/test_systems.py
+++ b/tests/test_systems.py
@@ -1,13 +1,7 @@
-import diffrax as dfx
-import jax.numpy as jnp
 import numpy as np
 import numpy.testing as npt
-from scipy.signal import dlsim, dlti
 
-from dynax import DynamicalSystem, FeedbackSystem, Flow, LinearSystem, Map, SeriesSystem
-
-
-tols = dict(rtol=1e-04, atol=1e-06)
+from dynax import FeedbackSystem, LinearSystem, SeriesSystem
 
 
 def test_series():
@@ -25,12 +19,12 @@ def test_series():
     sys2 = LinearSystem(A2, B2, C2, D2)
     sys = SeriesSystem(sys1, sys2)
     linsys = sys.linearize()
-    assert np.array_equal(
+    npt.assert_array_equal(
         linsys.A, np.block([[A1, np.zeros((n1, n2))], [B2.dot(C1), A2]])
     )
-    assert np.array_equal(linsys.B, np.block([[B1], [B2.dot(D1)]]))
-    assert np.array_equal(linsys.C, np.block([[D2.dot(C1), C2]]))
-    assert np.array_equal(linsys.D, D2.dot(D1))
+    npt.assert_array_equal(linsys.B, np.block([[B1], [B2.dot(D1)]]))
+    npt.assert_array_equal(linsys.C, np.block([[D2.dot(C1), C2]]))
+    npt.assert_array_equal(linsys.D, D2.dot(D1))
 
 
 def test_feedback():
@@ -48,111 +42,9 @@ def test_feedback():
     sys2 = LinearSystem(A2, B2, C2, D2)
     sys = FeedbackSystem(sys1, sys2)
     linsys = sys.linearize()
-    assert np.array_equal(
+    npt.assert_array_equal(
         linsys.A, np.block([[A1 + B1 @ D2 @ C1, B1 @ C2], [B2 @ C1, A2]])
     )
-    assert np.array_equal(linsys.B, np.block([[B1], [np.zeros((n2, m1))]]))
-    assert np.array_equal(linsys.C, np.block([[C1, np.zeros((p1, n2))]]))
-    assert np.array_equal(linsys.D, np.zeros((p1, m1)))
-
-
-class SecondOrder(DynamicalSystem):
-    """Second-order, linear system with constant coefficients."""
-
-    b: float
-    c: float
-    n_states = 2
-    n_inputs = 0
-
-    def vector_field(self, x, u=None, t=None):
-        """ddx + b dx + c x = u as first order with x1=x and x2=dx."""
-        x1, x2 = x
-        dx1 = x2
-        dx2 = -self.b * x2 - self.c * x1
-        return jnp.array([dx1, dx2])
-
-    def output(self, x, u=None, t=None):
-        x1, _ = x
-        return x1
-
-
-def test_forward_model_crit_damp():
-    b = 2
-    c = 1  # critical damping as b**2 == 4*c
-    sys = SecondOrder(b, c)
-
-    def x(t, x0, dx0):
-        """Solution to critically damped linear second-order system."""
-        C2 = x0
-        C1 = b / 2 * C2
-        return np.exp(-b * t / 2) * (C1 * t + C2)
-
-    x0 = jnp.array([1, 0])  # x(t=0)=1, dx(t=0)=0
-    t = np.linspace(0, 1)
-    model = Flow(sys, step=dfx.PIDController(rtol=1e-7, atol=1e-9))
-    x_pred = model(x0, t)[1]
-    x_true = x(t, *x0)
-    assert np.allclose(x_true, x_pred)
-
-
-def test_forward_model_lin_sys():
-    b = 2
-    c = 1  # critical damping as b**2 == 4*c
-    uconst = 1
-
-    A = jnp.array([[0, 1], [-c, -b]])
-    B = jnp.array([[0], [1]])
-    C = jnp.array([[1, 0]])
-    D = jnp.zeros((1, 1))
-    sys = LinearSystem(A, B, C, D)
-
-    def x(t, x0, dx0, uconst):
-        """Solution to critically damped linear second-order system."""
-        C2 = x0 - uconst / c
-        C1 = b / 2 * C2
-        return np.exp(-b * t / 2) * (C1 * t + C2) + uconst / c
-
-    x0 = jnp.array([1, 0])  # x(t=0)=1, dx(t=0)=0
-    t = np.linspace(0, 1)
-    u = np.ones(t.shape + (1,)) * uconst
-    model = Flow(sys, step=dfx.PIDController(rtol=1e-7, atol=1e-9))
-    x_pred = model(x0, t, u)[1]
-    x_true = x(t, x0[0], x0[1], uconst)
-    assert np.allclose(x_true, x_pred)
-
-
-def test_discrete_forward_model():
-    b = 2
-    c = 1  # critical damping as b**2 == 4*c
-    t = jnp.arange(50)
-    u = jnp.sin(1 / len(t) * 2 * np.pi * t)[:, None]  # single input
-    x0 = jnp.array([1.0, 0.0])
-    A = jnp.array([[0, 1], [-c, -b]])
-    B = jnp.array([[0], [1]])
-    C = jnp.array([[1, 0]])
-    D = jnp.zeros((1, 1))
-    # test just input
-    sys = LinearSystem(A, B, C, D)
-    model = Map(sys)
-    x, y = model(x0, u=u)  # ours
-    scipy_sys = dlti(A, B, C, D)
-    _, scipy_y, scipy_x = dlsim(scipy_sys, u, x0=x0)
-    npt.assert_allclose(scipy_y, y, **tols)
-    npt.assert_allclose(scipy_x, x, **tols)
-    # test input and time (results should be same)
-    x, y = model(x0, u=u, t=t)
-    scipy_t, scipy_y, scipy_x = dlsim(scipy_sys, u, x0=x0, t=t)
-    npt.assert_allclose(scipy_y, y, **tols)
-    npt.assert_allclose(scipy_x, x, **tols)
-
-        
-def test_initial_state():
-    class Sys(DynamicalSystem):
-        n_states = "scalar"
-        n_inputs = "scalar"
-
-        def vector_field(self, x, u, t=None):
-            return x * 0.1 + u
-
-    Sys(initial_state=1)
-            
+    npt.assert_array_equal(linsys.B, np.block([[B1], [np.zeros((n2, m1))]]))
+    npt.assert_array_equal(linsys.C, np.block([[C1, np.zeros((p1, n2))]]))
+    npt.assert_array_equal(linsys.D, np.zeros((p1, m1)))

From ae3f4c1f7904221852de17e66d7ffa03e0c1d7f5 Mon Sep 17 00:00:00 2001
From: fhchl <fhchl@users.noreply.github.com>
Date: Thu, 1 Feb 2024 16:44:41 +0100
Subject: [PATCH 03/10] test: run also notebooks

---
 examples/fit_ode.ipynb | 116 +++++++++++++++++++++++------------------
 tests/test_examples.py |  20 +++++--
 2 files changed, 82 insertions(+), 54 deletions(-)

diff --git a/examples/fit_ode.ipynb b/examples/fit_ode.ipynb
index 8a34322..55d9ffe 100644
--- a/examples/fit_ode.ipynb
+++ b/examples/fit_ode.ipynb
@@ -73,20 +73,28 @@
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "An NVIDIA GPU may be present on this machine, but a CUDA-enabled jaxlib is not installed. Falling back to cpu.\n"
+     ]
+    }
+   ],
    "source": [
     "class NonlinearDrag(DynamicalSystem):\n",
-    "    # Set the number of states (order of system) and inputs.\n",
-    "    n_states = 2\n",
-    "    n_inputs = 1\n",
-    "\n",
     "    # Declare parameters as dataclass fields.\n",
     "    m: float\n",
     "    r: float = non_negative_field()\n",
     "    r2: float = boxed_field(lower=0.01, upper=1)\n",
     "    k: float = boxed_field(lower=1e-3, upper=2)\n",
     "\n",
-    "    # Define the vector field of the dynamical system\n",
+    "    # Set the initial state of the system and the number of inputs.\n",
+    "    initial_state = jnp.zeros(2)\n",
+    "    n_inputs = \"scalar\"\n",
+    "\n",
+    "    # Define the vector field of the dynamical system.\n",
     "    def vector_field(self, x, u, t):\n",
     "        x1, x2 = x\n",
     "        return jnp.array(\n",
@@ -109,7 +117,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -118,11 +126,11 @@
      "text": [
       "true forward model: Flow(\n",
       "  system=NonlinearDrag(\n",
-      "    n_states(static)=2,\n",
-      "    n_inputs(static)=1,\n",
+      "    initial_state(static)=f64[2],\n",
+      "    n_inputs(static)='scalar',\n",
       "    m=1.0,\n",
       "    r(boxed: (0.0, inf))=2.0,\n",
-      "    r2(boxed: (0.01, 1))=0.15,\n",
+      "    r2(boxed: (0.01, 1))=3.0,\n",
       "    k(boxed: (0.001, 2))=1.0\n",
       "  ),\n",
       "  solver(static)=Dopri8(scan_kind=None),\n",
@@ -150,7 +158,7 @@
    ],
    "source": [
     "true_model = Flow(\n",
-    "    system=NonlinearDrag(m=1.0, r=2.0, r2=0.15, k=1.0),\n",
+    "    system=NonlinearDrag(m=1.0, r=2.0, r2=3., k=1.0),\n",
     "    solver=diffrax.Dopri8(),\n",
     "    step=diffrax.PIDController(rtol=1e-3, atol=1e-6),\n",
     ")\n",
@@ -166,12 +174,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -182,15 +190,13 @@
    ],
    "source": [
     "# time\n",
-    "t = np.linspace(0, 10, 1000)\n",
+    "t = jnp.linspace(0, 2, 20)\n",
     "# forcing signal\n",
-    "u = np.sin(t * 2 * np.pi)\n",
-    "# zero initial state\n",
-    "x0 = [0.0, 0.0]\n",
+    "u = 100*jnp.sin(t * 2 * np.pi)\n",
     "# x are the states and y is the output\n",
-    "x, y = true_model(x0, t, u)\n",
+    "x, y = true_model(t, u)\n",
     "# add noise to measurement\n",
-    "yn = y + np.random.normal(size=y.shape, scale=10)\n",
+    "yn = y + np.random.normal(size=y.shape, scale=100)\n",
     "\n",
     "plt.plot(t, yn, label=\"y+n\")\n",
     "plt.plot(t, y, label=\"y\")\n",
@@ -206,7 +212,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -215,12 +221,12 @@
      "text": [
       "initial system: Flow(\n",
       "  system=NonlinearDrag(\n",
-      "    n_states(static)=2,\n",
-      "    n_inputs(static)=1,\n",
-      "    m=2.0,\n",
+      "    initial_state(static)=f64[2],\n",
+      "    n_inputs(static)='scalar',\n",
+      "    m=1.0,\n",
       "    r(boxed: (0.0, inf))=1.0,\n",
       "    r2(boxed: (0.01, 1))=1.0,\n",
-      "    k(boxed: (0.001, 2))=2.0\n",
+      "    k(boxed: (0.001, 2))=1.0\n",
       "  ),\n",
       "  solver(static)=Tsit5(scan_kind=None),\n",
       "  step(static)=PIDController(\n",
@@ -247,7 +253,7 @@
    ],
    "source": [
     "init_model = Flow(\n",
-    "    system=NonlinearDrag(m=2.0, r=1.0, r2=1.0, k=2.0),\n",
+    "    system=NonlinearDrag(m=1.0, r=1.0, r2=1.0, k=1.0),\n",
     "    solver=diffrax.Tsit5(),\n",
     "    step=diffrax.PIDController(rtol=1e-3, atol=1e-6),\n",
     ")\n",
@@ -263,7 +269,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
@@ -271,28 +277,36 @@
      "output_type": "stream",
      "text": [
       "   Iteration     Total nfev        Cost      Cost reduction    Step norm     Optimality   \n",
-      "       0              1         5.1826e-01                                    4.19e-01    \n",
-      "       1              2         1.3715e-01      3.81e-01       1.01e+00       1.11e-01    \n",
-      "       2              3         1.2552e-01      1.16e-02       1.15e-01       8.01e-03    \n",
-      "       3             10         1.2550e-01      2.50e-05       2.57e-05       1.15e-02    \n",
-      "       4             13         1.2548e-01      1.87e-05       1.32e-06       8.07e-03    \n",
-      "       5             18         1.2548e-01      0.00e+00       0.00e+00       8.07e-03    \n",
+      "       0              1         1.6927e+00                                    5.15e-01    \n",
+      "       1              2         1.2288e-01      1.57e+00       6.59e+00       7.46e-02    \n",
+      "       2              3         2.1478e-02      1.01e-01       2.72e+00       1.70e-02    \n",
+      "       3              4         1.8862e-02      2.62e-03       3.15e-01       2.02e-03    \n",
+      "       4              5         1.8099e-02      7.63e-04       3.60e-01       8.95e-04    \n",
+      "       5              6         1.7903e-02      1.96e-04       1.97e-01       1.32e-04    \n",
+      "       6              9         1.7900e-02      3.55e-06       4.54e-03       1.17e-04    \n",
+      "       7             12         1.7899e-02      5.33e-07       6.28e-04       1.16e-04    \n",
+      "       8             13         1.7898e-02      1.27e-06       1.27e-03       1.15e-04    \n",
+      "       9             14         1.7897e-02      1.37e-06       2.57e-03       1.10e-04    \n",
+      "      10             16         1.7896e-02      5.21e-07       1.27e-03       1.08e-04    \n",
+      "      11             17         1.7893e-02      3.46e-06       1.40e-03       1.07e-04    \n",
+      "      12             19         1.7892e-02      6.18e-07       7.11e-04       1.06e-04    \n",
+      "      13             27         1.7892e-02      0.00e+00       0.00e+00       1.06e-04    \n",
       "`xtol` termination condition is satisfied.\n",
-      "Function evaluations 18, initial cost 5.1826e-01, final cost 1.2548e-01, first-order optimality 8.07e-03.\n",
+      "Function evaluations 27, initial cost 1.6927e+00, final cost 1.7892e-02, first-order optimality 1.06e-04.\n",
       "fitted system: NonlinearDrag(\n",
-      "  n_states(static)=2,\n",
-      "  n_inputs(static)=1,\n",
-      "  m=Array(0.96404107, dtype=float64),\n",
-      "  r(boxed: (0.0, inf))=Array(1.86260874, dtype=float64),\n",
-      "  r2(boxed: (0.01, 1))=Array(0.99998108, dtype=float64),\n",
-      "  k(boxed: (0.001, 2))=Array(1.0077622, dtype=float64)\n",
+      "  initial_state(static)=Array([0., 0.], dtype=float64),\n",
+      "  n_inputs(static)='scalar',\n",
+      "  m=Array(1.15256173, dtype=float64),\n",
+      "  r(boxed: (0.0, inf))=Array(10.09924961, dtype=float64),\n",
+      "  r2(boxed: (0.01, 1))=Array(1., dtype=float64),\n",
+      "  k(boxed: (0.001, 2))=Array(1.86684786, dtype=float64)\n",
       ")\n",
-      "Normalized mean squared error: [0.30761926]\n"
+      "Normalized mean squared error: [0.07727285]\n"
      ]
     }
    ],
    "source": [
-    "res = fit_least_squares(model=init_model, t=t, y=yn, x0=x0, u=u, verbose=2)\n",
+    "res = fit_least_squares(model=init_model, t=t, y=yn, u=u, verbose=2)\n",
     "pred_model = res.result\n",
     "print(\"fitted system:\", pretty(pred_model.system))\n",
     "print(\"Normalized mean squared error:\", res.nrmse)"
@@ -307,12 +321,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -322,7 +336,7 @@
     }
    ],
    "source": [
-    "x_pred, _ = pred_model(x0, t, u)\n",
+    "x_pred, _ = pred_model(t, u)\n",
     "\n",
     "plt.plot(t, yn, label=\"measurement\")\n",
     "plt.plot(t, res.y_pred, label=\"prediction\")\n",
@@ -341,12 +355,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 480x480 with 1 Axes>"
       ]
@@ -382,17 +396,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Flow.system.m: 0.000\n",
-      "Flow.system.r: 0.012\n",
-      "Flow.system.r2: 0.069\n",
-      "Flow.system.k: 0.000\n"
+      "Flow.system.m: 0.022\n",
+      "Flow.system.r: 1.810\n",
+      "Flow.system.r2: 0.378\n",
+      "Flow.system.k: 0.241\n"
      ]
     }
    ],
diff --git a/tests/test_examples.py b/tests/test_examples.py
index 5f9b28c..f5ec052 100644
--- a/tests/test_examples.py
+++ b/tests/test_examples.py
@@ -1,13 +1,27 @@
 import pathlib
 import runpy
 
+import nbformat
 import pytest
+from nbconvert.preprocessors import ExecutePreprocessor
 
 
 examples = pathlib.Path(__file__, "..", "..", "examples").resolve().glob("*.py")
+notebooks = pathlib.Path(__file__, "..", "..", "examples").resolve().glob("*.ipynb")
 
 
 @pytest.mark.slow
-@pytest.mark.parametrize("examples", examples)
-def test_examples_run_without_error(examples):
-    runpy.run_path(examples)
+@pytest.mark.parametrize("example", examples, ids=lambda x: str(x.name))
+def test_examples_run_without_error(example):
+    runpy.run_path(example)
+
+
+@pytest.mark.slow
+@pytest.mark.parametrize("notebook", notebooks, ids=lambda x: str(x.name))
+def test_notebooks_dont_change(notebook):
+    with open(notebook) as f:
+        nb = nbformat.read(f, as_version=4)
+        try:
+            ExecutePreprocessor(timeout=60).preprocess(nb)
+        except Exception as e:
+            raise Exception(f"Running the notebook {notebook} failed") from e

From 3f716d3ce3cc41e62bdc82e8a2facaf3835bab17 Mon Sep 17 00:00:00 2001
From: fhchl <fhchl@users.noreply.github.com>
Date: Thu, 1 Feb 2024 16:45:29 +0100
Subject: [PATCH 04/10] fix: use ufun

---
 dynax/evolution.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/dynax/evolution.py b/dynax/evolution.py
index 20a8f70..09bf952 100644
--- a/dynax/evolution.py
+++ b/dynax/evolution.py
@@ -69,18 +69,18 @@ def __call__(
             initial_state = self.system.initial_state
 
         # Prepare input function.
-        if u is None and ufun is None and ucoeffs is None and self.system.n_inputs == 0:
-            _ufun = lambda t: jnp.empty((0,))
-        elif ucoeffs is not None:
+        if ucoeffs is not None:
             path = dfx.CubicInterpolation(t, ucoeffs)
             _ufun = path.evaluate
-        elif callable(u):
+        elif callable(ufun):
             _ufun = u
         elif u is not None:
             u = jnp.asarray(u)
             if len(t) != u.shape[0]:
                 raise ValueError("t and u must have matching first dimension.")
             _ufun = spline_it(t, u)
+        elif self.system.n_inputs == 0:
+            _ufun = lambda t: jnp.empty((0,))
         else:
             raise ValueError("Must specify one of u, ufun, or ucoeffs.")
 

From 72fad3ae9c902c9ac5df48e650cbe2ff04b32b24 Mon Sep 17 00:00:00 2001
From: fhchl <fhchl@users.noreply.github.com>
Date: Thu, 1 Feb 2024 21:33:55 +0100
Subject: [PATCH 05/10] docs: don't expand jaxtyping types

---
 docs/source/conf.py | 20 ++++++++++++++++----
 dynax/estimation.py |  2 +-
 dynax/system.py     |  2 +-
 3 files changed, 18 insertions(+), 6 deletions(-)

diff --git a/docs/source/conf.py b/docs/source/conf.py
index f89159a..36d6396 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -5,6 +5,8 @@
 
 # -- Project information -----------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+import typing
+
 
 project = "Dynax"
 copyright = "2023, Franz M. Heuchel"
@@ -14,6 +16,7 @@
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
 
 extensions = [
+    "sphinx.ext.napoleon",
     "sphinx.ext.autodoc",
     "sphinx.ext.autosummary",
     "sphinx.ext.todo",
@@ -21,7 +24,7 @@
     "sphinx.ext.viewcode",
     "sphinxcontrib.bibtex",
     "sphinxcontrib.aafig",
-    "sphinx_autodoc_typehints",
+    #    "sphinx_autodoc_typehints",
     "nbsphinx",
 ]
 
@@ -41,11 +44,20 @@
 }
 
 autoclass_content = "both"
-# autodoc_typehints = "signature"
-# typehints_use_signature = "True"
+autodoc_typehints = "signature"
+typehints_use_signature = True
+
+
+napoleon_include_init_with_doc = True
+napoleon_preprocess_types = True
+napoleon_attr_annotations = True
 
 # -- Options for HTML output -------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
 
-html_theme = "furo"
+html_theme = "sphinx_rtd_theme"
 html_static_path = ["_static"]
+
+# Short type docs for jaxtyping's types
+# https://github.com/patrick-kidger/pytkdocs_tweaks/blob/2a7ce453e315f526d792f689e61d56ecaa4ab000/pytkdocs_tweaks/__init__.py#L283
+typing.GENERATING_DOCUMENTATION = True  # pyright: ignore
diff --git a/dynax/estimation.py b/dynax/estimation.py
index bc7d57d..d6ed789 100644
--- a/dynax/estimation.py
+++ b/dynax/estimation.py
@@ -13,7 +13,7 @@
 import scipy.signal as sig
 from jax import Array
 from jax.flatten_util import ravel_pytree
-from jax.typing import ArrayLike
+from jaxtyping import ArrayLike
 from numpy.typing import NDArray
 from scipy.linalg import pinvh
 from scipy.optimize import least_squares, OptimizeResult
diff --git a/dynax/system.py b/dynax/system.py
index b127d21..2dbf60b 100644
--- a/dynax/system.py
+++ b/dynax/system.py
@@ -10,7 +10,7 @@
 import jax.numpy as jnp
 import numpy as np
 from jax import Array
-from jax.typing import ArrayLike
+from jaxtyping import ArrayLike
 
 from .util import dim2shape
 

From 3563b668274e7043a5ac8fa2107d963b2f5b16c2 Mon Sep 17 00:00:00 2001
From: fhchl <fhchl@users.noreply.github.com>
Date: Fri, 2 Feb 2024 10:41:43 +0100
Subject: [PATCH 06/10] fix examples

---
 dynax/linearize.py                            |  4 ++--
 .../fit_multiple_shooting_second_order_sys.py | 10 ++++-----
 examples/fit_second_order_sys.py              |  9 ++++----
 examples/linearize_discrete_time.py           | 21 +++++++++----------
 4 files changed, 20 insertions(+), 24 deletions(-)

diff --git a/dynax/linearize.py b/dynax/linearize.py
index 1335c6a..e9958d4 100644
--- a/dynax/linearize.py
+++ b/dynax/linearize.py
@@ -226,8 +226,8 @@ class DiscreteLinearizingSystem(DynamicalSystem, _CoupledSystemMixin):
 
     def __init__(
         self,
-        sys: ControlAffine,
-        refsys: LinearSystem,
+        sys: DynamicalSystem,
+        refsys: DynamicalSystem,
         reldeg: int,
         **fb_kwargs,
     ):
diff --git a/examples/fit_multiple_shooting_second_order_sys.py b/examples/fit_multiple_shooting_second_order_sys.py
index 429745a..ad35b20 100644
--- a/examples/fit_multiple_shooting_second_order_sys.py
+++ b/examples/fit_multiple_shooting_second_order_sys.py
@@ -35,7 +35,7 @@ class NonlinearDrag(ControlAffine):
     k: float
 
     # Set the number of states (order of system), the number of inputs
-    n_states = 2
+    initial_state = jnp.zeros(2)
     n_inputs = "scalar"
 
     # Define the dynamical system via the methods f, g, and h
@@ -68,8 +68,7 @@ def h(self, x):
     ),
     axis=0,
 )
-initial_x = [0.0, 0.0]
-x_train, y_train = true_model(initial_x, t_train, u_train)
+x_train, y_train = true_model(t_train, u_train)
 
 # create our model system with some initial parameters
 initial_sys = NonlinearDrag(m=1.0, r=1.0, r2=1.0, k=1.0)
@@ -83,7 +82,6 @@ def h(self, x):
     model=init_model,
     t=t_train,
     y=y_train,
-    x0=initial_x,
     u=u_train,
     verbose=2,
     num_shots=num_shots,
@@ -96,10 +94,10 @@ def h(self, x):
 print("fitted system:", tree_pformat(model.system))
 
 # check the results
-x_pred, y_pred = model(initial_x, t_train, u_train)
+x_pred, y_pred = model(t_train, u_train)
 
 # plot
-xs_pred, _ = jax.vmap(model)(x0s, ts0, us)
+xs_pred, _ = jax.vmap(model)(ts0, us, initial_state=x0s)
 plt.plot(t_train, x_train, "k--", label="target")
 for i in range(num_shots):
     plt.plot(ts[i], xs_pred[i], label="multiple shooting", color=f"C{i}")
diff --git a/examples/fit_second_order_sys.py b/examples/fit_second_order_sys.py
index f85cf04..69ee4b6 100644
--- a/examples/fit_second_order_sys.py
+++ b/examples/fit_second_order_sys.py
@@ -29,7 +29,7 @@ class NonlinearDrag(ControlAffine):
     k: float
 
     # Set the number of states (order of system), the number of in- and outputs.
-    n_states = 2
+    initial_state = jnp.zeros(2)
     n_inputs = "scalar"
 
     # Define the dynamical system via the methods f, g, and h
@@ -57,8 +57,7 @@ def h(self, x):
 samplerate = 1 / t_train[1]
 np.random.seed(42)
 u_train = np.random.normal(size=len(t_train))
-initial_x = [0.0, 0.0]
-x_train, y_train = true_model(initial_x, t_train, u_train)
+x_train, y_train = true_model(t_train, u_train)
 
 # create our model system with some initial parameters
 initial_sys = NonlinearDrag(m=1.0, r=1.0, r2=1.0, k=1.0)
@@ -76,12 +75,12 @@ def h(self, x):
 init_model = Flow(initial_sys)
 # Fit all parameters with previously estimated parameters as a starting guess.
 pred_model = fit_least_squares(
-    model=init_model, t=t_train, y=y_train, x0=initial_x, u=u_train, verbose=0
+    model=init_model, t=t_train, y=y_train, u=u_train, verbose=0
 ).result
 print("fitted system:", pred_model.system)
 
 # check the results
-x_pred, y_pred = pred_model(initial_x, t_train, u_train)
+x_pred, y_pred = pred_model(t_train, u_train)
 assert np.allclose(x_train, x_pred)
 
 plt.plot(t_train, x_train, "--", label="target")
diff --git a/examples/linearize_discrete_time.py b/examples/linearize_discrete_time.py
index c8cef09..c641a3e 100644
--- a/examples/linearize_discrete_time.py
+++ b/examples/linearize_discrete_time.py
@@ -20,9 +20,10 @@ class Recurrent(DynamicalSystem):
     n_inputs = "scalar"
 
     def __init__(self, hidden_size, *, key):
-        input_size = 1
-        self.cell = GRUCell(input_size, hidden_size, use_bias=False, key=key)
-        self.n_states = hidden_size
+        self.cell = GRUCell(
+            input_size=1, hidden_size=hidden_size, use_bias=False, key=key
+        )
+        self.initial_state = jnp.zeros(hidden_size)
 
     def vector_field(self, x, u, t=None):
         return self.cell(jnp.array([u]), x)
@@ -51,14 +52,14 @@ def output(self, x, u=None, t=None):
 # degree of the nonlinear system. Here we test for the relative degree with a set of
 # points and inputs.
 reldeg = discrete_relative_degree(
-    system, np.random.normal(size=(inputs.size, system.n_states)), inputs
+    system, np.random.normal(size=(len(inputs),) + system.initial_state.shape), inputs
 )
 print("Relative degree of nonlinear system:", reldeg)
 print(
     "Relative degree of reference system:",
     discrete_relative_degree(
         reference_system,
-        np.random.normal(size=(inputs.size, reference_system.n_states)),
+        np.random.normal(size=(len(inputs),) + reference_system.initial_state.shape),
         inputs,
     ),
 )
@@ -69,14 +70,12 @@ def output(self, x, u=None, t=None):
 
 # The output of this system when driven with the reference input is the linearizing
 # input. The coupled system as an extra state used internally.
-_, linearizing_inputs = Map(linearizing_system)(
-    jnp.zeros(system.n_states + reference_system.n_states + 1), u=inputs
-)
+_, linearizing_inputs = Map(linearizing_system)(u=inputs)
 
 # Lets simulate the original system, the linear reference and the linearized system.
-states_orig, output_orig = Map(system)(x0=jnp.zeros(hidden_size), u=inputs)
-_, output_ref = Map(reference_system)(x0=jnp.zeros(reference_system.n_states), u=inputs)
-_, output_linearized = Map(system)(jnp.zeros(hidden_size), u=linearizing_inputs)
+states_orig, output_orig = Map(system)(u=inputs)
+_, output_ref = Map(reference_system)(u=inputs)
+_, output_linearized = Map(system)(u=linearizing_inputs)
 
 assert np.allclose(output_ref, output_linearized)
 

From 7749cd7a617e4987a767f2003973dbdb5d0054d4 Mon Sep 17 00:00:00 2001
From: fhchl <fhchl@users.noreply.github.com>
Date: Fri, 2 Feb 2024 11:56:11 +0100
Subject: [PATCH 07/10] fix tests

---
 pyproject.toml | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index d1e4295..80cff55 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -13,13 +13,8 @@ dependencies = ["jax>=0.4.23", "diffrax>=0.5"]
 [project.optional-dependencies]
 dev = [
     "pytest",
+    "jupyter",
     "matplotlib",
-    "sphinx",
-    "sphinx-autobuild",
-    "sphinx_autodoc_typehints",
-    "furo",
-    "sphinxcontrib-bibtex",
-    "nbsphinx",
     "pre-commit",
 ]
 

From 1e856a140a1f4447f6d91eecf0e5abafaac9c66d Mon Sep 17 00:00:00 2001
From: fhchl <fhchl@users.noreply.github.com>
Date: Sun, 4 Feb 2024 20:54:47 +0100
Subject: [PATCH 08/10] remove x0 parameters from fit functions

---
 .gitignore               |  2 +-
 dynax/estimation.py      | 44 +++++++++-------------
 dynax/evolution.py       | 15 +++++---
 dynax/example_models.py  |  2 +-
 examples/fit_ode.ipynb   | 79 +++++++++++++++++++---------------------
 tests/test_estimation.py | 76 +++++++++++++++++++-------------------
 tests/test_evolution.py  |  4 +-
 7 files changed, 106 insertions(+), 116 deletions(-)

diff --git a/.gitignore b/.gitignore
index 28200c7..e4a81e3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,7 +5,7 @@ experiments
 .coverage
 htmlcov
 build
-docs/source/_build
+_build
 docs/generated
 *.pytest_cache
 .pytype
diff --git a/dynax/estimation.py b/dynax/estimation.py
index d6ed789..be043c7 100644
--- a/dynax/estimation.py
+++ b/dynax/estimation.py
@@ -92,7 +92,7 @@ def _compute_covariance(
 
 def _least_squares(
     f: Callable[[Array], Array],
-    x0: NDArray,
+    init_params: Array,
     bounds: tuple[list, list],
     reg_term: Optional[Callable[[Array], Array]] = None,
     x_scale: bool = True,
@@ -105,7 +105,7 @@ def _least_squares(
         # Add regularization term
         _f = f
         _reg_term = reg_term  # https://github.com/python/mypy/issues/7268
-        f = lambda x: jnp.concatenate((_f(x), _reg_term(x)))
+        f = lambda params: jnp.concatenate((_f(params), _reg_term(params)))
 
     if verbose_mse:
         # Scale cost to mean-squared error
@@ -117,15 +117,17 @@ def f(params):
 
     if x_scale:
         # Scale parameters and bounds by initial values
-        norm = np.where(np.asarray(x0) != 0, np.abs(x0), 1)
-        x0 = x0 / norm
+        norm = np.where(np.asarray(init_params) != 0, np.abs(init_params), 1)
+        init_params = init_params / norm
         ___f = f
-        f = lambda x: ___f(x * norm)
+        f = lambda params: ___f(params * norm)
         bounds = (np.array(bounds[0]) / norm, np.array(bounds[1]) / norm)
 
     fun = MemoizeJac(jax.jit(lambda x: value_and_jacfwd(f, x)))
     jac = fun.derivative
-    res = least_squares(fun, x0, bounds=bounds, jac=jac, x_scale="jac", **kwargs)
+    res = least_squares(
+        fun, init_params, bounds=bounds, jac=jac, x_scale="jac", **kwargs
+    )
 
     if x_scale:
         # Unscale parameters
@@ -139,8 +141,8 @@ def f(params):
 
     if reg_term is not None:
         # Remove regularization from residuals and Jacobian and cost
-        res.fun = res.fun[: -len(x0)]
-        res.jac = res.jac[: -len(x0)]
+        res.fun = res.fun[: -len(init_params)]
+        res.jac = res.jac[: -len(init_params)]
         res.cost = np.sum(res.fun**2) / 2
 
     return res
@@ -150,7 +152,6 @@ def fit_least_squares(
     model: AbstractEvolution,
     t: ArrayLike,
     y: ArrayLike,
-    x0: Optional[ArrayLike] = None,
     u: Optional[ArrayLike] = None,
     batched: bool = False,
     sigma: Optional[ArrayLike] = None,
@@ -169,11 +170,6 @@ def fit_least_squares(
     t = jnp.asarray(t)
     y = jnp.asarray(y)
 
-    if x0 is not None:
-        x0 = jnp.asarray(x0)
-    else:
-        x0 = model.system.initial_state
-
     if batched:
         # First axis holds experiments, second axis holds time.
         std_y = np.std(y, axis=1, keepdims=True)
@@ -216,7 +212,7 @@ def residual_term(params):
             # this can use pmap, if batch size is smaller than CPU cores
             model = jax.vmap(model)
         # FIXME: ucoeffs not supported for Map
-        _, pred_y = model(t=t, ucoeffs=ucoeffs, initial_state=x0)
+        _, pred_y = model(t=t, ucoeffs=ucoeffs)
         res = (y - pred_y) * weight
         return res.reshape(-1)
 
@@ -250,7 +246,6 @@ def fit_multiple_shooting(
     model: AbstractEvolution,
     t: ArrayLike,
     y: ArrayLike,
-    x0: Optional[ArrayLike] = None,
     u: Optional[Union[Callable[[float], Array], ArrayLike]] = None,
     num_shots: int = 1,
     continuity_penalty: float = 0.1,
@@ -278,11 +273,6 @@ def fit_multiple_shooting(
     t = jnp.asarray(t)
     y = jnp.asarray(y)
 
-    if x0 is not None:
-        x0 = jnp.asarray(x0)
-    else:
-        x0 = model.system.initial_state
-
     if u is None:
         msg = (
             f"t, y must have same number of samples, but have shapes "
@@ -308,11 +298,13 @@ def fit_multiple_shooting(
     t = t[:num_samples]
     y = y[:num_samples]
 
+    n_states = len(model.system.initial_state)
+
     # TODO: use numpy for everything that is not jitted
     # Divide signals into segments.
     ts = _moving_window(t, num_samples_per_segment, num_samples_per_segment - 1)
     ys = _moving_window(y, num_samples_per_segment, num_samples_per_segment - 1)
-    x0s = np.zeros((num_shots - 1, len(x0)))
+    x0s = np.zeros((num_shots - 1, n_states))
 
     ucoeffs = None
     if u is not None:
@@ -329,8 +321,8 @@ def fit_multiple_shooting(
     std_y = np.std(y, axis=0)
     parameter_bounds = _get_bounds(model)
     state_bounds = (
-        (num_shots - 1) * len(x0) * [-np.inf],
-        (num_shots - 1) * len(x0) * [np.inf],
+        (num_shots - 1) * n_states * [-np.inf],
+        (num_shots - 1) * n_states * [np.inf],
     )
     bounds = (
         state_bounds[0] + parameter_bounds[0],
@@ -339,7 +331,7 @@ def fit_multiple_shooting(
 
     def residuals(params):
         x0s, model = unravel(params)
-        x0s = jnp.concatenate((x0[None], x0s), axis=0)
+        x0s = jnp.concatenate((model.system.initial_state[None], x0s), axis=0)
         xs_pred, ys_pred = jax.vmap(model)(t=ts0, ucoeffs=ucoeffs, initial_state=x0s)
         # output residual
         res_y = ((ys - ys_pred) / std_y).reshape(-1)
@@ -353,7 +345,7 @@ def residuals(params):
     res = _least_squares(residuals, init_params, bounds, x_scale=False, **kwargs)
 
     x0s, res.result = unravel(res.x)
-    res.x0s = np.asarray(jnp.concatenate((x0[None], x0s), axis=0))
+    res.x0s = jnp.concatenate((res.result.system.initial_state[None], x0s), axis=0)
     res.ts = np.asarray(ts)
     res.ts0 = np.asarray(ts0)
 
diff --git a/dynax/evolution.py b/dynax/evolution.py
index 09bf952..57c2b0d 100644
--- a/dynax/evolution.py
+++ b/dynax/evolution.py
@@ -42,10 +42,9 @@ class Flow(AbstractEvolution):
     """Evolution for continous-time dynamical systems."""
 
     solver: dfx.AbstractAdaptiveSolver = eqx.static_field(default_factory=dfx.Dopri5)
-    step: dfx.AbstractStepSizeController = eqx.static_field(
-        default_factory=dfx.ConstantStepSize
-    )  # TODO: replace with adaptive step size
-    dt0: Optional[float] = eqx.static_field(default=None)
+    stepsize_controller: dfx.AbstractStepSizeController = eqx.static_field(
+        default_factory=lambda: dfx.ConstantStepSize()
+    )
 
     def __call__(
         self,
@@ -95,11 +94,15 @@ def __call__(
         # Solve ODE.
         diffeqsolve_default_options = dict(
             solver=self.solver,
-            stepsize_controller=self.step,
+            stepsize_controller=self.stepsize_controller,
             saveat=dfx.SaveAt(ts=t),
             max_steps=50 * len(t),  # completely arbitrary number of steps
             adjoint=dfx.DirectAdjoint(),
-            dt0=self.dt0 if self.dt0 is not None else t[1],
+            dt0=(
+                t[1]
+                if isinstance(self.stepsize_controller, dfx.ConstantStepSize)
+                else None
+            ),
         )
         diffeqsolve_default_options |= diffeqsolve_kwargs
         vector_field = lambda t, x, self: self.system.vector_field(x, _ufun(t), t)
diff --git a/dynax/example_models.py b/dynax/example_models.py
index df741d3..eb60a9a 100644
--- a/dynax/example_models.py
+++ b/dynax/example_models.py
@@ -102,7 +102,7 @@ class LotkaVolterra(DynamicalSystem):
     gamma: float = non_negative_field()
     delta: float = non_negative_field()
 
-    initial_state = jnp.ones(2)
+    initial_state = jnp.ones(2) * 0.5
     n_inputs = 0
 
     def vector_field(self, x, u=None, t=None):
diff --git a/examples/fit_ode.ipynb b/examples/fit_ode.ipynb
index 55d9ffe..857d6e6 100644
--- a/examples/fit_ode.ipynb
+++ b/examples/fit_ode.ipynb
@@ -117,7 +117,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
@@ -134,7 +134,7 @@
       "    k(boxed: (0.001, 2))=1.0\n",
       "  ),\n",
       "  solver(static)=Dopri8(scan_kind=None),\n",
-      "  step(static)=PIDController(\n",
+      "  stepsize_controller(static)=PIDController(\n",
       "    rtol=0.001,\n",
       "    atol=1e-06,\n",
       "    pcoeff=0,\n",
@@ -150,17 +150,16 @@
       "    norm=<function rms_norm>,\n",
       "    safety=0.9,\n",
       "    error_order=None\n",
-      "  ),\n",
-      "  dt0(static)=None\n",
+      "  )\n",
       ")\n"
      ]
     }
    ],
    "source": [
     "true_model = Flow(\n",
-    "    system=NonlinearDrag(m=1.0, r=2.0, r2=3., k=1.0),\n",
+    "    system=NonlinearDrag(m=1.0, r=2.0, r2=3.0, k=1.0),\n",
     "    solver=diffrax.Dopri8(),\n",
-    "    step=diffrax.PIDController(rtol=1e-3, atol=1e-6),\n",
+    "    stepsize_controller=diffrax.PIDController(rtol=1e-3, atol=1e-6),\n",
     ")\n",
     "print(\"true forward model:\", true_model)"
    ]
@@ -174,12 +173,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -192,7 +191,7 @@
     "# time\n",
     "t = jnp.linspace(0, 2, 20)\n",
     "# forcing signal\n",
-    "u = 100*jnp.sin(t * 2 * np.pi)\n",
+    "u = 100 * jnp.sin(t * 2 * np.pi)\n",
     "# x are the states and y is the output\n",
     "x, y = true_model(t, u)\n",
     "# add noise to measurement\n",
@@ -212,7 +211,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -229,7 +228,7 @@
       "    k(boxed: (0.001, 2))=1.0\n",
       "  ),\n",
       "  solver(static)=Tsit5(scan_kind=None),\n",
-      "  step(static)=PIDController(\n",
+      "  stepsize_controller(static)=PIDController(\n",
       "    rtol=0.001,\n",
       "    atol=1e-06,\n",
       "    pcoeff=0,\n",
@@ -245,8 +244,7 @@
       "    norm=<function rms_norm>,\n",
       "    safety=0.9,\n",
       "    error_order=None\n",
-      "  ),\n",
-      "  dt0(static)=None\n",
+      "  )\n",
       ")\n"
      ]
     }
@@ -255,7 +253,7 @@
     "init_model = Flow(\n",
     "    system=NonlinearDrag(m=1.0, r=1.0, r2=1.0, k=1.0),\n",
     "    solver=diffrax.Tsit5(),\n",
-    "    step=diffrax.PIDController(rtol=1e-3, atol=1e-6),\n",
+    "    stepsize_controller=diffrax.PIDController(rtol=1e-3, atol=1e-6),\n",
     ")\n",
     "print(\"initial system:\", init_model)"
    ]
@@ -269,7 +267,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -277,31 +275,28 @@
      "output_type": "stream",
      "text": [
       "   Iteration     Total nfev        Cost      Cost reduction    Step norm     Optimality   \n",
-      "       0              1         1.6927e+00                                    5.15e-01    \n",
-      "       1              2         1.2288e-01      1.57e+00       6.59e+00       7.46e-02    \n",
-      "       2              3         2.1478e-02      1.01e-01       2.72e+00       1.70e-02    \n",
-      "       3              4         1.8862e-02      2.62e-03       3.15e-01       2.02e-03    \n",
-      "       4              5         1.8099e-02      7.63e-04       3.60e-01       8.95e-04    \n",
-      "       5              6         1.7903e-02      1.96e-04       1.97e-01       1.32e-04    \n",
-      "       6              9         1.7900e-02      3.55e-06       4.54e-03       1.17e-04    \n",
-      "       7             12         1.7899e-02      5.33e-07       6.28e-04       1.16e-04    \n",
-      "       8             13         1.7898e-02      1.27e-06       1.27e-03       1.15e-04    \n",
-      "       9             14         1.7897e-02      1.37e-06       2.57e-03       1.10e-04    \n",
-      "      10             16         1.7896e-02      5.21e-07       1.27e-03       1.08e-04    \n",
-      "      11             17         1.7893e-02      3.46e-06       1.40e-03       1.07e-04    \n",
-      "      12             19         1.7892e-02      6.18e-07       7.11e-04       1.06e-04    \n",
-      "      13             27         1.7892e-02      0.00e+00       0.00e+00       1.06e-04    \n",
+      "       0              1         1.6932e+00                                    5.19e-01    \n",
+      "       1              2         1.2050e-01      1.57e+00       6.56e+00       7.58e-02    \n",
+      "       2              3         2.1584e-02      9.89e-02       2.69e+00       1.97e-02    \n",
+      "       3              4         1.8803e-02      2.78e-03       3.26e-01       2.40e-03    \n",
+      "       4              5         1.8095e-02      7.08e-04       3.40e-01       2.85e-03    \n",
+      "       5              6         1.7878e-02      2.17e-04       2.22e-01       1.79e-03    \n",
+      "       6              7         1.7854e-02      2.34e-05       1.01e-01       8.56e-04    \n",
+      "       7             10         1.7842e-02      1.26e-05       6.96e-03       7.91e-05    \n",
+      "       8             16         1.7842e-02      7.74e-08       1.66e-05       7.91e-05    \n",
+      "       9             18         1.7842e-02      1.64e-09       8.29e-06       7.95e-05    \n",
+      "      10             23         1.7842e-02      0.00e+00       0.00e+00       7.95e-05    \n",
       "`xtol` termination condition is satisfied.\n",
-      "Function evaluations 27, initial cost 1.6927e+00, final cost 1.7892e-02, first-order optimality 1.06e-04.\n",
+      "Function evaluations 23, initial cost 1.6932e+00, final cost 1.7842e-02, first-order optimality 7.95e-05.\n",
       "fitted system: NonlinearDrag(\n",
       "  initial_state(static)=Array([0., 0.], dtype=float64),\n",
       "  n_inputs(static)='scalar',\n",
-      "  m=Array(1.15256173, dtype=float64),\n",
-      "  r(boxed: (0.0, inf))=Array(10.09924961, dtype=float64),\n",
+      "  m=Array(1.16036016, dtype=float64),\n",
+      "  r(boxed: (0.0, inf))=Array(10.03637659, dtype=float64),\n",
       "  r2(boxed: (0.01, 1))=Array(1., dtype=float64),\n",
-      "  k(boxed: (0.001, 2))=Array(1.86684786, dtype=float64)\n",
+      "  k(boxed: (0.001, 2))=Array(1.91832787, dtype=float64)\n",
       ")\n",
-      "Normalized mean squared error: [0.07727285]\n"
+      "Normalized mean squared error: [0.07717369]\n"
      ]
     }
    ],
@@ -321,12 +316,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -355,12 +350,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAg8AAAHpCAYAAAAF0N+gAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABiRElEQVR4nO3de1yO9/8H8NfdQXV3rqUDklMlh7SYrxyqLSaHCWGYhGy2WWyY2QH7bXMaG7ahzeS4mDmOmA13yFDIoRKVpETUXSKdr98fzaV7ylzUfXd4PR+P68F93Z/ruj/X+z697s/1ue9kgiAIICIiInpKWpruABEREdUtDA9EREQkCcMDERERScLwQERERJIwPBAREZEkDA9EREQkCcMDERERScLwQERERJIwPBAREZEkDA9EREQkCcMDERERScLwQERERJIwPBAREZEkOpruABE9ThAEyGQyTXeDqEYdOnQIZ86cwZUrVzBhwgS4u7tDW1tb092ip8CRB6JapqysTAwO9+/fV7lOEARNdImo2q1ZswajR4/GoUOHcOLECXh5eSEiIgJA+XOAajeZwFcjolpp0aJFOHLkCMzMzDBx4kR4eHhAV1eXoxJU5+3btw9jx47FypUr4efnB21tbYwdOxaxsbE4deoUtLT4uba24z1EVAt99913WLRoEV588UWcPn0aM2fOREhICIqKiiCTyTgCQXVWXl4efvvtN4wfPx5+fn7i+kGDBqGgoEBzHavH/j2SUx2vHwwPRLXAv5/cmZmZWLVqFf7v//4P58+fh7OzMzZt2oRVq1YxQFSTivVjLdVDEAQYGxvDxcUFjo6O0NbWFuc4ODg44M6dO8jKykJJSYmGe1o/PHxcPxzJOXbsmMpp0efB8ECkYYIgiE/uvXv3YufOnUhPT4e1tTUAQFdXFz/88AOcnZ0RFhaGkJAQFBYW8tTFc6h46kepVLKWalCx5u+88w7Gjx+vcr2Ojo7Y7uH/d+/eDaVSqd6O1iMymQylpaUAgNDQUEyZMqXaTgnx2xZEGlTxBfWDDz7A2rVroa2tjaysLJSWlsLDwwPa2towNDTEDz/8gODgYCxduhQ2NjYYNmyYhntfN1Ws+ZtvvgmFQoHz589DX19fwz2rvyrWPCgoCEeOHMH58+ehp6enEtzkcjleeOEFAICXlxeKioowcOBAjfS5Lvvggw+QmpqK3377TRzZ0dbWhoODAwCgpKREDGjPiiMPRBr08IUzMTERly5dwp9//ono6GhMmzYNsbGxmD17tvjJQS6XY9myZZgwYQKGDBmiyW7XaRVrfvPmTaxevZrBoYZVrHlmZqZY84rBQRAElJWV4c6dO+jXrx9u3bqFiIgInqKTqKCgAFZWVkhKSsJbb70lrr9x44ZKkHheDA9EGrZu3Tq88cYbMDAwQPv27dG8eXN89tln6NOnD/766y989tlnYoAwNDTExx9/DG1tbXEdSbdu3TqMGjUKRUVF6Ny5M2upBv9Vc11dXRQXF6N37964fPkyzp8/D11dXZSUlPC0kgT6+vqYPHkyJkyYgJMnTyIoKAgAUFRUJM6tqqyeUgMaT1sQaVBRURFu3ryJ3Nxc3L17F3p6egAAExMTfPTRRwCAiIgITJkyBcuXL1c5X8kf03k2RUVFyMjIwL1795CVlQW5XA4AKC0tZU1ryNPU/MGDB8jIyECLFi0QHR0tBofnHV5vaB5OSh07diwEQcDq1asxZcoUNG3aFBYWFti2bRuMjY1hZGSEoqIipKamYsiQITAyMpJ0O/ydByINy8vLw8aNG/Hll1+iT58+CA0NVblu1qxZKCoqQkhICD+BVZOHNZ87dy569+6NjRs3AmCAqElPU/Nvv/0WkydPZnB4Tg/nmOTl5SE0NBTr1q3D2bNnYWNjAwcHB1y/fh3a2trQ0tJCy5YtceDAAckTKRkeiDTo4ZP83r17CA0Nxc8//4wuXbrgp59+Etvk5+fDwMBAPPfLAPF8Htbw/v37WLNmDVavXo2XXnpJrDkDRPX7r5oXFBSozDthcHh+/w4QW7duhYWFBXbt2gUAyM7OhomJCbS0tKClpYWysjJJAYJzHog06GEgMDIyQmBgICZMmIDo6GiViU5yuZzBoRo9rKWhoSECAwMRFBSkUnMGh+r3XzX/94RVBofn97DmxsbGCAwMxLBhw5CcnIy3334bAGBhYQEdHZ1nCg4A5zwQ1bj/emL++0kuk8kwb948tGzZEjNnzlRpR0+numpOT481V7+nrbmJiQnGjRsHLS0tzJs3Dw4ODio1f5bffuBpC6IaVPHJHRMTA2NjY1haWsLMzAxA+dDiwx+JejhUm52djYMHD2LIkCH8FPwMWHP1Y83VT+M1F4ioxs2YMUOwt7cXTExMhICAAGH//v0q1+fk5AifffaZcPHiRZX1JSUl6uxmvcKaqx9rrn6aqjnnPBDVAKHCgN6RI0ewZ88ebNq0Cd9++y2ysrKwcOFCceISABw/fhwbNmwQv2nxcHt+Int6rLn6sebqV2tq/lzRg4geU1paqnL5yJEjQnBwsHj5+PHjwpAhQwRPT09h586d4vpdu3bxE9gzYs3VjzVXv9pUc855IKohS5YswYkTJ1BcXAwbGxusWrVKvO7vv//GkiVLoFQqMX78eIwePVq8jl8VfHasufqx5upXG2rO0xZE1aTin9WeN28evvjiC+jr6yMxMRHr16/HL7/8Il7frVs3TJ8+HWVlZfj7779V9sMX1KfHmqsfa65+tbLm1TqOQUTC2bNnhSVLlggKhUIQBEG4cOGCEBQUJLRt21YICwtTaXvx4sXHhiJJOtZc/Vhz9atNNWd4IKpGBw8eFGQymWBtbS2cPHlSXH/+/Hlh4sSJQtu2bYXNmzc/th1fWJ8da65+rLn61baa87QFUTV6+OMrOTk5OHv2rLi+Q4cOCA4OhqenJ9555x389ddfKts9y4+0UDnWXP1Yc/WrdTWvkUhC1ABUlegzMzOF4OBgQV9fX9iwYYPKdWfOnBEWLlzI2ebPiDVXP9Zc/epCzfnz1ETPoOKvu4WEhODKlStITk7GuHHj0KNHD3z55ZfQ0dHBO++8AwB44403AABubm5wc3MDwNnmUrHm6seaq1+dqblaIgpRPfXhhx8KjRs3Fj777DNh9OjRQqtWrYR33nlHKC0tFVJTU4Xp06cLZmZmQkhIiKa7Wm+w5urHmqtfba85wwPRMzpw4IDQsmVLITo6Wryso6MjbNq0SWxz69YtISgoSPDx8dFUN+sV1lz9WHP1qws1Z3ggekr/Ppe4ZcsWoUePHoIgCMLmzZsFY2NjYcWKFYIgCEJeXp4QGRkpCEL5ecqysjL1draeYM3VjzVXv7pYc059JXpKD88hXrhwAQBQUFAAAwMDHDp0CBMnTsSCBQvw9ttvAwD++OMPbN68Gbdv34aVlRVkMpnKD73Q02HN1Y81V786WXONRBaiOmTHjh3CjBkzBEEQhClTpggDBw4UiouLhezsbKFp06aCTCYTNm7cKLZ/8OCB0K9fPyEgIICfxJ4Ra65+rLn61eWaMzwQPUFhYaGwdOlSwcDAQOjevbtgbGys8qdtd+3aJdja2grDhw8Xjh49KuzcuVN49dVXhQ4dOgjFxcWCIAgaf5LXNay5+rHm6lfXa87wQPQfioqKhF69egkymUyYMGGCynV5eXlCeHi40K5dO6Fp06aCu7u7MHToUKGoqEgQhMfPZdLTYc3VjzVXv7pcc/5VTaJKVPyu9f379/HNN9/g3r17+PnnnzFhwgQsXLgQACAIAmQyGUpKSpCeng59fX00btxYXKejw59SeVqsufqx5upXX2rOe5zoXyo+uTdv3gw7OztMnz4dMpkMTZo0wdy5cyGTybBgwQLIZDIAwLlz5+Du7q6yD00/uesS1lz9WHP1q1c11+SwB1FtU/Ec4syZMwVra2vh559/FrKysgRBEITs7Gxh+fLlgoWFhfD+++8Lubm5Qt++fWvFBKa6ijVXP9Zc/epbzRkeiCqxaNEioXHjxkJUVJR4bvHhE7i4uFgICQkRDA0NhVatWgmurq7ieUh6dqy5+rHm6ldfas45D0R4dH5REAQUFxfj9ddfh7u7Oz755BNcu3YNFy9exKpVq+Ds7IxRo0bBzc0NKSkpuHjxInx9faGtrV0rzkPWJay5+rHm6ldfa87wQFRBcnIyWrZsiR49eqBFixbw8vLCzp07UVBQAC0tLeTn56NVq1ZYuXIlDAwMxO34x3+eHWuufqy5+tW3mvMXJon+8euvv+K9994DAHz00UeIiorC7Nmz0blzZ3z++ef4448/0LNnT9y9e1flyQ2gVj656wLWXP1Yc/WrjzWvXeMgRBpUVFSEw4cPIy4uDgMGDBBnONva2optYmJi0KxZM011sd5hzdWPNVe/+lhznragBunhV6aE8knD4tenXnvtNRgYGGDdunXQ19cHAOTm5iIyMhIrV67E1atXERMTAx0dHfFcJj0d1lz9WHP1ayg152kLapAePqErPrkFQUCfPn2QnJyM3NxcsW1aWhq++eYbaGtr4+zZs9DR0UFpaWmtf3LXNqy5+rHm6tdgal7TX+cgqq1+/PFHoWnTpkJYWJgQFxcnCIIgFBQUCC1bthQmT56s0vbq1atCaWmpIAiC+LvyJB1rrn6sufo1hJrztAU1GBV/3Q0oP8f4/fffIyYmBvfv38eoUaMwZswYREZGIiwsDIsXL4aTkxMAiJ8E/r0PejLWXP1Yc/VriDVneKAGoeITc8WKFdDR0cGbb74JALh48SJOnjyJ+fPno3nz5khPT0dOTg6+//57+Pv714nzj7URa65+rLn6Ndiaa27Qg0j9ZsyYIdjb2wtfffWVkJqaqnJdWlqasGvXLmHo0KGCjo6O0KFDByE9PV1DPa0/WHP1Y83Vr6HVnOGBGowffvhBsLKyEqKjo/+zbVhYmODu7i5ERkYKgiDUyt+WrwtYc/VjzdWvIda87pxgIXoOxcXFOHv2LN588024u7vj0qVLWLduHf73v//Bx8cHCoUCAFBSUgIAeP3116Gvr4/Vq1cDQN0dWtQg1lz9WHP1a6g1549EUYOgq6sLAwMDhISEoFmzZli3bh3MzMzw8ssv4/Dhw5g2bRpOnjwpflVKW1sbrVq1gq6ubq38Xfm6gDVXP9Zc/RpszTU99EFU3aoaBoyPjxcCAgIEe3t7Yf78+cKZM2cEQRCE/fv3C15eXoJSqRS3j4qKEuRyuRATE6OubtdprLn6sebqx5o/wm9bUL337z8sk5OTAzMzMwDlP97St29fmJqaYsuWLSpDiJmZmWjcuLG6u1svsObqx5qrX0OuOcMD1UuLFy/G5cuX8eOPPwJ4/DvU+fn52L9/P1auXInMzExER0dDV1dX5Sdlhbr8NSoNYM3VjzVXP9a8HCdMUr3w7wxsZ2eHyMhI7N+/H0D5T8aWlZWJ1ycnJyMqKgqNGzfG6dOnxfOPMplMfCGo60/umsaaqx9rrn6seeU48kB1XmUpPjU1FTNmzICVlRUWLVoEAwMDyGQy3L17F3l5eWjSpAmysrJgYWEBmUz22PAjPRlrrn6sufqx5k+gjokVROrw1VdfCd27dxcuXbokCIIgHDp0SNDX1xd+//13QRAEobCwUPDz8xPc3NyEq1evitvV1e9Z1wasufqx5urHmj+O4YHqvLKyMqGgoEDo1q2bIJPJhMGDBwtz584Vrl27Jixfvlxo3ry5kJycLAiCIJw4cULw8fER/xANPRvWXP1Yc/VjzavGOQ9UJwkVzraVlZVBT08Pa9euhbu7O3R0dFBSUoI+ffogNTUVbdu2RWhoKO7du4euXbvizz//fOw8Jf031lz9WHP1Y82fDuc8UJ32/fffw8jICJ6enmjRogWWLFmCtLQ0TJgwAYmJiZgyZQqUSiW0tLRw8uRJODk51YuZzprEmqsfa65+rPmT1dGftiIqd+LECSQmJiIsLAxz5sxBv3798N577+HatWvw8/ODi4sL1qxZg9jYWLRu3RpA/ZjprEmsufqx5urHmj8ZRx6ozqjq790fPHgQW7duxerVq/Htt9/i1KlTUCgUOHHiBJo0aYL8/HzI5XIAj/+oCz0Za65+rLn6sebSMTxQnVDxyb17927cuXMH9+/fx6hRo2BpaQkACAsLw7x589C2bVv89ttveO+997BgwQIYGBgAqPxrV1Q11lz9WHP1Y82fkbpnaBI9jw8++ECwsrISXnrpJcHU1FRwdXUV1qxZI+Tn5wuCIAjnz58X5s+fLxgaGgr9+/ev11+VUhfWXP1Yc/VjzaVheKA6Y/PmzYKNjY0QExMjPHjwQCgsLBSGDx8udOvWTdiyZYv4Fani4mLh6tWrQklJiSAI9fu71jWNNVc/1lz9WHPp+FVNqpXWrFmDxMRElXWpqalo2bIlnJ2doaOjg0aNGmHt2rUwMTHB999/Lw496ujowMHBAdra2igtLW14w4nPiDVXP9Zc/Vjz6sHwQLXO77//js8++ww//PADUlJSxPX37t1DXl4e9PT0oKOjg4KCAhgYGGDhwoWIiopCTEzMY79D35AmMD0P1lz9WHP1Y82rD8MD1To+Pj6YNWsWjhw5gqVLl+Lq1asAgJEjR+Ly5cv4+OOPAQD6+voAgLy8PLRo0QKmpqYN+pPA82DN1Y81Vz/WvPrwdx6oVlmyZAlWrVqFuLg4FBcXY8OGDQCA9957D87Ozli+fDmmTp2K+/fv48033wQALFiwAI0bN0bz5s012fU6izVXP9Zc/VjzaqbZKRdEj6xatUrQ09MTNm3aJK5bsmSJ0LFjR2HKlCnC9evXBUEQhLCwMMHGxkawtbUVWrduLXh4eAhFRUWCIAgN5nflqwtrrn6sufqx5tWP4YFqhR9//FFo1KiRsGPHjkqvc3V1FaZMmSJcu3ZNEARBuHPnjnD8+HEhOjpaZSY0PT3WXP1Yc/VjzWsGwwNp3OHDhwWZTCZ8/vnnKutHjx4tLFq0SBCE8k8JnTp1EqZOnSpcuXLlsX08/OoUPR3WXP1Yc/VjzWsOJ0ySxjVp0gQ9evTA6dOnER0dDQAYOnQoTp8+jWHDhgEAPvjgAwQEBODYsWP46quvkJGRobKPhj7zWSrWXP1Yc/VjzWsOf56aaoUrV64gODgY2trayM3NRX5+PrZt2wYHBweV34z/4osvkJycjJ9//rnS36Knp8eaqx9rrn6seQ3R9NAH0UOXL18WfHx8BFNTU+HXX38V15eVlalMVnr4q26cwPT8WHP1Y83VjzWvfhx5oFolKSkJ7777LrS0tPDxxx+jR48eACD+QMvD71oLDfEP0dQQ1lz9WHP1Y82rF8dmqFZp1aoVvvvuOwiCgK+++gqRkZEAyp/YFZ/QfHJXH9Zc/Vhz9WPNqxfDA9U6bdq0wfLly6GtrY2pU6fi/Pnzmu5Svceaqx9rrn6sefVheKBaqU2bNvj666/Rq1cvtG/fXtPdaRBYc/VjzdWPNa8enPNAdUJZWRlnQKsZa65+rLn6sebPhuGBiIiIJGHcIiIiIkkYHoiIiEgShgciIiKShOGBiIiIJGF4oFqvsLAQc+fORWFhoaa70mCw5urHmqsfa/7s+G0LqvXu3r0LU1NT5ObmwsTERNPdaRBYc/VjzdWPNX92HHkgIiIiSRgeiIiISBIdTXeA1KOsrAw3btyAsbFxnfvDL3fv3lX5l2oea65+rLn61dWaC4KAvLw82NnZaezXMTnnoYFIS0tDs2bNNN0NIiKqJtevX0fTpk01ctsceWggjI2NAQDd3adDR0dPw71pQBjN1a9uDawRSVZSUojI04vF13VNYHhoIB6eqtDR0YOOjr6Ge9OAMDyoH8MDNRCaPAXNCZNEREQkCcMDERERScLwQERERJIwPBAREZEkDA9EREQkCcMDERERScLwQERERJIwPBAREZEkDA9EREQkCcMDERERScLwQERERJIwPBAREZEkDA9EREQkCcMDERERScLwQERERJIwPBAREZEkDA9EREQkCcMDERERScLwQERERJIwPBAREZEkDA9EREQkCcMDERERScLwQERERJIwPBAREZEkDA9EREQkCcMDERERScLwQERERJIwPBAREZEkDA9EREQkCcMDERERScLwQERERJIwPBAREZEkDA9EREQkCcMDERERScLwQERERJIwPBAREZEkDA9EREQkCcMDERERSaKj6Q5Qw/TaEHcMH9kNFhZGSEq6he+//QMJ8TeqbN/Luy0CgzxhY2OG9LRs/LTyIE6dSFJpM3aCJ/oN7AQjY33EXkjDssXhSE9T1vSh1CljgyrU6PzT1ei1Ie4YPuqf+yrx8ftKt5E2Jk3uDW8fF+jq6iD6VBKWLd6PHOX9mj6cWo+Pc/VjzdWjWkcevLy8MHXq1OrcJdVDXi+7YNLk3tgQehSTJqxGcuItLPhmJMzM5JW2d2nfFJ/MGYz9e2IwafxPiDyagM/nD4dDCyuxzYjR3TDYvwuWLd6HyW+GouBBERZ8Mwq6jbTVdVi1nlijr/dh8sRQFBT8d428XnHBpPd6Y8Oao5g0vvL76p3gPujWvQ3+79Pt+GDyeli+YIy58/zVcUi1Gh/n6seaq4/k8BAYGAiZTPbYkpiYWBP9U7u1a9fCzMxM092o14a+3hXhv5/FH+HnkJpyB0u/DkdhQTH6DuhUafshw7og6mQSfg07gdRrWVi7OgKJlzMwaGjnCm1ewqb1x3D82GVcTcrEwi93w9LSGN17OqnpqGq/IcNfwqZ1FWr0xW5YvvDkGg0dUcl9VfjovjI01EPfAZ2w8rs/EXMmBVcSbuLrr35H+47N0LZdEzUdWe3Ex7n6sebq80wjD3379kVGRobK0qJFi+ruG9VDOjpacHS0xZnoq+I6QQDORKfApYo3G5f2TVXaA0DUyWS4tG8KALC1M4PlC8Y4E/Wozf37hYiPSxfbNHRijaKfvkY6OlpwdLJVqat4X7Uvv6/aONlCV1dbZb/XU7Nw62au2KYh4uNc/Vhz9Xqm8KCnpwcbGxuVRVv78SEcpVKJgIAAmJubQy6Xw9fXF1euXAEACIIAKysr/Pbbb2L7Tp06wdbWVrx87Ngx6OnpIT8//7F9r1ixAm3atIG+vj6sra3h718+TLp+/XpYWlqisLBQpb2fnx/GjBkDADh37hy8vb1hbGwMExMTuLu7Izo6GgqFAuPGjUNubq44ojJ37lwAQGFhIaZPn44mTZrA0NAQXbt2hUKhEPf/cMRiz549cHJyglwuh7+/P/Lz87Fu3To4ODjA3NwcwcHBKC0trbK2c+fORadOnbBmzRrY29vDyMgI77zzDkpLS7Fo0SLY2NigcePG+Oqrr/7jXqqdTE3l0NbRgjJb9Xy4MvsezC2NKt3G3MIIyn+dP89R3oeFhaF4PYAntmnoxBr9q+452fdhYVl5jUzNnnBf/bM/C0tDFBWV4P69wirbNER8nKsfa65eNTphMjAwEFeuXMHu3bthYmKCmTNnol+/foiLi4Ouri569eoFhUIBf39/KJVKxMfHw8DAAJcuXYKzszMiIiLQpUsXyOWq56uio6MRHByMDRs2wMPDA9nZ2Th69CgAYNiwYQgODsbu3bsxbNgwAEBmZib27t2LAwcOAABGjx4NNzc3rFy5Etra2oiJiYGuri48PDywdOlSzJ49GwkJCQAAI6PyB8/kyZMRFxeHzZs3w87ODjt27EDfvn1x4cIFtGnTBgCQn5+P5cuXY/PmzcjLy8OQIUMwePBgmJmZITw8HMnJyRg6dCi6d++OESNGVFm3pKQk7Nu3D/v370dSUhL8/f2RnJwMR0dHRERE4Pjx4xg/fjx8fHzQtWvXSvdRWFioEqDu3r37LHch1VEv92mP92f0Ey9/MmOzBntDRPXNM4WHPXv2iG+qAODr64utW7eqtHkYGiIjI+Hh4QEA2LRpE5o1a4adO3di2LBh8PLyQkhICADgyJEjcHNzg42NDRQKBZydnaFQKODp6fnY7aempsLQ0BADBgyAsbExmjdvDjc3NwCAgYEBRo0ahdDQUDE8bNy4Efb29vDy8hK3nzFjBpydnQFAfPMHAFNTU8hkMtjY2KjcXmhoKFJTU2FnZwcAmD59Ovbv34/Q0FDMmzcPAFBcXIyVK1eiVatWAAB/f39s2LABt27dgpGREVxcXODt7Y3Dhw8/MTyUlZVhzZo1MDY2FrdJSEhAeHg4tLS04OTkhIULF+Lw4cNVhof58+fj888/r/I2NCU3Nx+lJWUw/1dqN7cwgjLrXqXbKLPvwdxctb2ZuSGy//mEocwu387c3BDZFfZhZm6IpMRb1dn9OuPvY5dxKTZdvPxwcpe5xb9qZGGIpCuV1yg35wn31T81z866j0aNdGBopKcy+lCxTUPEx7n6sebq9UynLby9vRETEyMuy5cvf6xNfHw8dHR0VN7cLC0t4eTkhPj4eACAp6cn4uLicPv2bURERMDLywteXl5QKBQoLi7G8ePHxTf8inr37o3mzZujZcuWGDNmDDZt2qRyamPixIk4cOAA0tPLXzzXrl0rTvQEgA8++ABBQUHw8fHBggULkJSU9NhtVHThwgWUlpbC0dERRkZG4hIREaGyrVwuF4MDAFhbW8PBwUElaFlbWyMzM/OJt+fg4ABjY2OVbVxcXKClpaWy7kn7mTVrFnJzc8Xl+vXrT7xNdSkpKcPlyxl40f3RHBmZDHBzd0BchTe7iuIupsGts4PKOvcuLRB3MQ0AkHEjB1l38lTayOWN0NalidimoXmQX4Qb6UpxuXb1TnmN3B3ENv9Vo5KSMlxOyMCLnSu5ry6W31dXEjJQXFyq0qapvQWsbUzFNg0RH+fqx5qr1zOFB0NDQ7Ru3VpcKs5TkKJDhw6wsLBARESESniIiIhAVFQUiouLxVGLioyNjXHmzBmEhYXB1tYWs2fPhqurK3JycgAAbm5ucHV1xfr163H69GnExsYiMDBQ3H7u3LmIjY1F//79cejQIbi4uGDHjh1V9vPevXvQ1tbG6dOnVUJTfHw8li1bJrbT1dVV2U4mk1W6rqys7Il1qY796OnpwcTERGWpLbZtPol+A93Qu29H2De3xJTp/aBvoIv9e88BAGZ++homvOUttt++NQpduraC/+td0czeEgHje8HR2Q67tkVXaHMKo8f2QLfubdCipRVmfjoIWVl5iDyaoPbjq622//pPjXr8U6PPBiHrjmqNFi0brTLTfNuWf+4r3wr3lf6j++r+/cLyr7m91xuuLzZHGycbzPh4IGIvXEd8FS/YDQUf5+rHmqtPjc15aNu2LUpKSnDy5EkxAGRlZSEhIQEuLi4Ayt8Ae/bsiV27diE2NhY9evSAXC5HYWEhQkJC0LlzZxgaVj4pRUdHBz4+PvDx8cGcOXNgZmaGQ4cOYciQIQCAoKAgLF26FOnp6fDx8UGzZs1Utnd0dISjoyPef/99jBw5EqGhoRg8eDAaNWr02IRGNzc3lJaWIjMzEz179qzuUjU4ikNxMDWTIzDIE+YW5cN/s6aFiT8q1NjaFGVlgtg+7mIa5n2+E+MmemH8m95IT8vGnFm/IuXqbbHNlk1/Q1+/Ed7/sD+MjPRx8cJ1fDQtDMVFVU9ObWi2bPob+gYVanT+8RrZNTGHqemjOUaKg/+6r66o3lcAsGL5AZSVCZjzlT90dbURfSoZyxfvU+ux1UZ8nKsfa64+NRYe2rRpg0GDBmHixIkICQmBsbExPvroIzRp0gSDBg0S23l5eWHatGno3LmzOLzfq1cvbNq0CTNmzBDbOTs7Y/78+Rg8eDD27NmD5ORk9OrVC+bm5ggPD0dZWRmcnB5973bUqFGYPn06fvrpJ6xfv15c/+DBA8yYMQP+/v5o0aIF0tLSEBUVhaFDhwIoP2Vw7949HDx4EK6urpDL5XB0dMTo0aMREBCAJUuWwM3NDbdv38bBgwfRsWNH9O/f/5nrNGvWLKSnp6v0sSHYtT0au7ZHV3rdtPc2PLbuyOF4HDkc/8R9rvs5Aut+jqiW/tVX61ZHYN3qqmv0hv/3j63btS1a5ZPYvxUXleK7b/bju2/2V0sf6xM+ztWPNVePGv3bFqGhoXB3d8eAAQPQrVs3CIKA8PBwlSF4T09PlJaWqsxt8PLyemxdQkICcnNzAQBmZmbYvn07Xn75ZbRt2xarVq1CWFgY2rVrJ7Y3NTXF0KFDYWRkBD8/P3G9trY2srKyEBAQAEdHRwwfPhy+vr7i5EIPDw9MmjQJI0aMgJWVFRYtWiQeS0BAAKZNmwYnJyf4+fkhKioK9vb2z1WjjIwMpKamPtc+iIiI1EkmCILw383qpldeeQXt2rWrdEJnQ3P37l2YmprCs+sn0NHR13R3Go56++yqxWSa7gBRzSopKUDEya+Qm5ursfls9fIPYymVSigUCigUCqxYsULT3SEiIqpX6mV4cHNzg1KpxMKFC1XmQRAREdHzq5fhISUlRdNdICIiqrdqdMIkERER1T8MD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkuhougOkZsI/C6nFgW3rNN2FBudVu06a7kKDo9O0iaa70KDIygo13QWOPBAREZE0DA9EREQkCcMDERERScLwQERERJIwPBAREZEkDA9EREQkCcMDERERScLwQERERJIwPBAREZEkDA9EREQkCcMDERERScLwQERERJIwPBAREZEkDA9EREQkCcMDERERScLwQERERJIwPBAREZEkDA9EREQkCcMDERERScLwQERERJIwPBAREZEkDA9EREQkCcMDERERScLwQERERJIwPBAREZEkDA9EREQkCcMDERERScLwQERERJIwPBAREZEkDA9EREQkCcMDERERScLwQERERJIwPBAREZEkDA9EREQkCcMDERERScLwQERERJIwPBAREZEkDA9EREQkCcMDERERScLwQERERJLoaLoD1HCNDfJEv4GdYGSsj9jzaVi2OBzpaconbvPaEHcMH9UNFhZGSEq8he+//QMJ8TfE63UbaWPS5N7w9nGBrq4Ook8lYdni/chR3q/pw6m9DEZBJh8JaDctv1xyBcK974GiI5W312kNmdFUQLcdZNpNUXb3KyB/rWobmWF5G/3egJYlUBwH4e6XQMmFGjyQumns5yPgG/QKjMwMERt5Ccvf+QnpiTefuI2lnQWCFozGS75u0JPr4UbiTSwe/wMun04W29g7N0HQgjfQ0dMFWjpaSI1Lw+f+S3D7+p2aPqRab8wHvug76n8wNDFAXPRVfP/xVtxIqbou/d/ojv5jusO6qQUA4Nrlm/hl2R+IVsSLbRZumYyO3VqrbLd3YyS+/3hrzRxELafWkQcvLy9MnTpVnTdJtdSI0d0w2L8Lln29D5MnhqKgoAgLvhkF3UbaVW7j9YoLJr3XGxvWHMWk8auRnHgLC74ZCTMzudjmneA+6Na9Df7v0+34YPJ6WL5gjLnz/NVxSLVX2U0IeYshZPlByBoMFP0NmflKQKd1FRsYAKXXy7cpzay0hczkK6BRdwg5MyDc6Q8UHYPMYh2gZV1zx1EHjfhwEPze88Wyt3/Ee/+bhYL7hZi//1Po6ulWuY2RmSGWHvsCpcWl+LjfPAS1ex8h09chr0IAtm1pjW+PfoHUhHRM856Dt1ynY9OX21BcUKSOw6rVhr39Cl4b1wvfzdqKqa99i4L8Iny5cRJ09ar+rHznZg5CF/yO9/ovRvCAJTh3/DJmr54Ae0cblXb7fjmOUe6ficuaebtr+nBqrWoPD4GBgZDJZI8tiYmJ1X1TGrF27VqYmZlpuht13pDhL2HTumM4fuwyriZlYuEXu2H5gjG693SqcpuhI7oi/Pez+CP8HFJT7mDp1+EoLCxG3wGdAACGhnroO6ATVn73J2LOpOBKwk18/dXvaN+xGdq2a6KmI6uFCg8BRRFA6TWgNAXCvW8BIR/Q7VR5+5ILEPIWAgV7AVT2ZqQH6L8K4d4ioDgKKE2FcO87oPQaZPJRNXggdc/gKf2x6att+Ht3NK5eSMXCsd/D0s4c3f26VLnNiJl+uH09C4snrEBCVCJupmTi9J/nkZF8S2wz7suROBV+FqtnbkRSTAoykm/h79+jkXP7rjoOq1bzm9ALm787gBN/XkTKpQwsfn8TLBubwqNPhyq3OflXLKIOx+NGyh2kX72NdV+HoyC/EM5uzVXaFT4ohvJ2nrjk3yus6cOptWpk5KFv377IyMhQWVq0aFETN9XgFRXVvU8atnZmsHzBGGeir4rr7t8vRHxcOlzaN610Gx0dLTg62eJM1KNtBAE4E50Cl/blwaCNky10dbVV9ns9NQu3buaKbUgL0O8PyORAUcyz7UKmA5lMBxD+9cIpFACN3J+7h/WFTYvGsLQ1x9m/Hp3Kyb+bj0snE+HSreqQ3G1gZ1w+nYTPtnyAX2+uxsrTi+Ab9Ip4vUwmQ9f+LyLtyg3M3/cJfr25Gsv/ngePQVUHkobCxt4SFo1NcfbYZXFdfl4BEmKuwdnd4an2oaUlg+dAN+gb6OHSmRSV67z93LE55kus/HMmAmcOgJ5+1SNI9V2NhAc9PT3Y2NioLNrajw9HK5VKBAQEwNzcHHK5HL6+vrhy5QoAQBAEWFlZ4bfffhPbd+rUCba2tuLlY8eOQU9PD/n5+Y/te8WKFWjTpg309fVhbW0Nf//yoev169fD0tIShYWqL3x+fn4YM2YMAODcuXPw9vaGsbExTExM4O7ujujoaCgUCowbNw65ubniiMrcuXMBAIWFhZg+fTqaNGkCQ0NDdO3aFQqFQtz/wxGLPXv2wMnJCXK5HP7+/sjPz8e6devg4OAAc3NzBAcHo7S0tMrazp07F506dcLq1avRokUL6Ovr/8e9UfuYWxgBAJTZqvMQcrLvw8LSsNJtTM3k0NbRemwbZfY9cX8WloYoKirB/X99GqjYpsHScYSscQxk1rGQmfwfBOU7QOkzjgYK9yEUnYHM6F1AqzHKA8lrgK4boGVVrd2uyyxszAAAyls5KuuVt3Jgbm1W5Xa2LRtj4KQ+SE/MwKy+X+L3VQfw7rLx6B3gCQAwa2wKubEBRsz0Q9QfMZj16peI3HkKc7ZNR8deLjV0NHWDuZUxAEB5J09lvfJOHsytTJ64rYOTLbbHL8TuxMWYPG84vnjzZ6ReeTTao9h1GoumbMRHI37Arz/8hVeGdMaMZW9U/0HUERqdMBkYGIgrV65g9+7dMDExwcyZM9GvXz/ExcVBV1cXvXr1gkKhgL+/P5RKJeLj42FgYIBLly7B2dkZERER6NKlC+Ryucp+o6OjERwcjA0bNsDDwwPZ2dk4evQoAGDYsGEIDg7G7t27MWzYMABAZmYm9u7diwMHDgAARo8eDTc3N6xcuRLa2tqIiYmBrq4uPDw8sHTpUsyePRsJCQkAACOj8jelyZMnIy4uDps3b4adnR127NiBvn374sKFC2jTpg0AID8/H8uXL8fmzZuRl5eHIUOGYPDgwTAzM0N4eDiSk5MxdOhQdO/eHSNGjKiybomJidi2bRu2b99eaSgDysNMxYB0967mhjNf7tMe78/oJ17+ZMZmjfWlwSq5CiHrNUBmDJl+X8jMFkHIGv3MAULInQGZ6XxoNY6EIJQAxbFAwR5At301d7zueHlUD0xd9ZZ4+dMB859pPzItLVyOTsKaT8IAAEkxKXBo3wwD3uqDP9dHQEtLBgD4e1c0ti/dW97mXAradXPCgLd64/yRuOc8krrD288d780fLl6eE/jjM+8rLTkT7/b9GoYm+ujRrxOmfTMaHw7/TgwQ+375W2ybkpCB7My7WLD5Xdg2t0TGtaxnP4g6qkbCw549e8Q3VQDw9fXF1q2qM1IfhobIyEh4eHgAADZt2oRmzZph586dGDZsGLy8vBASEgIAOHLkCNzc3GBjYwOFQgFnZ2coFAp4eno+dvupqakwNDTEgAEDYGxsjObNm8PNzQ0AYGBggFGjRiE0NFQMDxs3boS9vT28vLzE7WfMmAFnZ2cAEN/8AcDU1BQymQw2NjYqtxcaGorU1FTY2dkBAKZPn479+/cjNDQU8+bNAwAUFxdj5cqVaNWqFQDA398fGzZswK1bt2BkZAQXFxd4e3vj8OHDTwwPRUVFWL9+Paysqv6UN3/+fHz++edVXq9Ofx+7jEux6eLlh5MizS0MkZ11T1xvZmGIpApJv6LcnHyUlpTB3EJ1ZMLcwgjK7PJ9ZGfdR6NGOjA00lMZfajYpuEqBkpTAQDCvVjIdDtAZjgWwt3Pnm13pakQskdDkBkAMiOg7DZkpkuBkuvV1+U65u/d0bh08lEYezhBz9zaDNk3c8T15tZmSDqXUuV+sjOUSI1PU1mXGp+OnkP+BwDIvZOHkuISXItXrXXqpTS07+78nEdRt5z48yIunb0mXhZr/oIxlJmPPjCZv2CMpLj0x7avqKS4FBnXyr+RkXghDY6uzTBovCe+m/Vrpe0f3q5tc6sGGR5q5LSFt7c3YmJixGX58uWPtYmPj4eOjg66du0qrrO0tISTkxPi48u/HuPp6Ym4uDjcvn0bERER8PLygpeXFxQKBYqLi3H8+HHxDb+i3r17o3nz5mjZsiXGjBmDTZs2qZzamDhxIg4cOID09PIH09q1a8WJngDwwQcfICgoCD4+PliwYAGSkpKeeLwXLlxAaWkpHB0dYWRkJC4REREq28rlcjE4AIC1tTUcHBxUgpa1tTUyMyuf4f5Q8+bNnxgcAGDWrFnIzc0Vl+vXNfei/iC/CDfSleJy7eodZN3Jg1uFc5ByeSO0dWmCuItple6jpKQMlxMy8GLnR3NnZDLAzd0BcRfL78crCRkoLi5VadPU3gLWNqZiG3pIC5A1ev7dCA+AstuAzATQ6wmh8K/n32cd9eBeAW4k3RSXa3FpyMpQwu2VR6MxcmMDOHdtjbi/E6rcT2xkApo62qmsa+poi1vXbgMASopLkBCVhGaOqvN4mrSxw61rDetrmg/uFyLj2h1xSb18E9mZuejU/dEHPrmRHpw6Ncel0ymS9i2TyaDbqOrP163+mYSdnZn7TH2v62okPBgaGqJ169biUnGeghQdOnSAhYUFIiIiVMJDREQEoqKiUFxcLI5aVGRsbIwzZ84gLCwMtra2mD17NlxdXZGTkwMAcHNzg6urK9avX4/Tp08jNjYWgYGB4vZz585FbGws+vfvj0OHDsHFxQU7duyosp/37t2DtrY2Tp8+rRKa4uPjsWzZMrGdrq7q5BqZTFbpurKysifWxdCw8nkBFenp6cHExERlqU22/3oKo8f2QLcebdCipRVmfjYIWXfyEHn00YvqomWjMWhoZ/Hyti0n0W+gG3r7doR9c0tMmd4P+vq62L/3HIDySZf798Rg0nu94fpic7RxssGMjwci9sJ1xMc23PAgM5oG6HYBtJuUz30wmgY06grhQfnXzGSmi8rXiXQBnbblC3Qh07Yu/7+2/aMmjXoAjXqW/3ZEo+6QWWwESpKBB9vUemy13Y5lezHqk6HoNrAzHNrb48N1k5F1Q4nInVFim0V/zsagd/uKl7ct3YO2/2uDkbMGw66VDbxH9kC/iT7YvWK/2Gbr4t3wHOEB36BXYNfKBoPe7YtuA92xe+Ufaj2+2mjnz0fwenAfdO3dDg5Otpj27RvIyszF8QOPJq7OD3sHA8f2EC8HzhyA9i+1ROOmFnBwskXgzAHo2K01Du+MBgDYNrfEyOA+aN2hKRo3tUDX3u0w/dvRuHAiESmXMtR+jLWBxuY8tG3bFiUlJTh58qQYALKyspCQkAAXl/JJPzKZDD179sSuXbsQGxuLHj16QC6Xo7CwECEhIejcuXOVb6Q6Ojrw8fGBj48P5syZAzMzMxw6dAhDhgwBAAQFBWHp0qVIT0+Hj48PmjVrprK9o6MjHB0d8f7772PkyJEIDQ3F4MGD0ahRo8cmNLq5uaG0tBSZmZno2bNndZeqXtqy6W/oGzTC+x/2h5GRPi6ev46PpoWhuOhRbe2amMPU9NF8FsXBOJiayREY5Anzf05xzJoWpvIDUCuWH0BZmYA5X/lDV1cb0aeSsXzxPrUeW62jZQmZ2aLyyY1leUDJJQjK8UBRZPn12nYAhEfttRtD64UK3183DILMMAhC0UkI2f9MENMyhsxoOqBtA5TlAAV/QLj3DYASNR1U3bBl0S7oG+pjashbMDKT4+KxS5jl+xWKC4vFNratrGHygrF4+XJ0EuYO+RoT5o3GG5/54+bVTKx8fy0O/XJMbBO58xSWvf0jRn40GO8uG4+0hBv43H8xYiMvqfX4aqOtKw9C36ARguePgJGJAWKjk/HZmBAUFz56bNravwCTCpOozSyNMP3bN2DR2AT38x7g6qUb+HTMKpw9Wv6tjeKiUrj1cITfBE/oGzTC7YwcHNt3DpuXH1D78dUWGgsPbdq0waBBgzBx4kSEhITA2NgYH330EZo0aYJBgwaJ7by8vDBt2jR07txZHN7v1asXNm3ahBkzZojtnJ2dMX/+fAwePBh79uxBcnIyevXqBXNzc4SHh6OsrAxOTo++HjVq1ChMnz4dP/30E9avXy+uf/DgAWbMmAF/f3+0aNECaWlpiIqKwtChQwEADg4OuHfvHg4ePAhXV1fI5XI4Ojpi9OjRCAgIwJIlS+Dm5obbt2/j4MGD6NixI/r37//MdZo1axbS09NV+lhfrFsdgXWrI6q8/g3/7x9bt2tbNHZti65ym+KiUnz3zX58983+Kts0NMLdj598ffa/ZoyXpqPsZpvKGz9UsA9CQQMPZU9p3ZwtWDdnS5XXj2n57mPrTu49g5N7zzxxv3+EHsYfoYefu3/10YZv9mHDN1U/PgO7/5/K5aUfPnkS952MHHw4/PHXo4ZMo3/bIjQ0FO7u7hgwYAC6desGQRAQHh6uMpTv6emJ0tJSlbkNXl5ej61LSEhAbm75uSczMzNs374dL7/8Mtq2bYtVq1YhLCwM7dq1E9ubmppi6NChMDIygp+fn7heW1sbWVlZCAgIgKOjI4YPHw5fX19x8qGHhwcmTZqEESNGwMrKCosWLRKPJSAgANOmTYOTkxP8/PwQFRUFe/sKQ73PICMjA6mpqc+1DyIiouokEwRB+O9m9dMrr7yCdu3aVTqhs765e/cuTE1N4fnSJ9DRqXu/DVFXHdi2TtNdaHBeteuk6S40ODpN+SNs6lRSVoi/0lchNzdXY/PZGuQfxlIqlVAoFFAoFFixYoWmu0NERFSnNMjw4ObmBqVSiYULF6rMgyAiIqL/1iDDQ0pKiqa7QEREVGdpdMIkERER1T0MD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkuhougOkZrJ/FlKLV+06aboLDU6xj7umu9DglBWXaboLDUpJSQGQrtk+cOSBiIiIJGF4ICIiIkkYHoiIiEgShgciIiKShOGBiIiIJGF4ICIiIkkYHoiIiEgShgciIiKShOGBiIiIJGF4ICIiIkkYHoiIiEgShgciIiKShOGBiIiIJGF4ICIiIkkYHoiIiEgShgciIiKShOGBiIiIJGF4ICIiIkkYHoiIiEgShgciIiKShOGBiIiIJGF4ICIiIkkYHoiIiEgShgciIiKShOGBiIiIJGF4ICIiIkkYHoiIiEgShgciIiKShOGBiIiIJGF4ICIiIkkYHoiIiEgShgciIiKShOGBiIiIJGF4ICIiIkkYHoiIiEgShgciIiKShOGBiIiIJGF4ICIiIkkYHoiIiEgShgciIiKSREfTHaCG6bUh7hg+shssLIyQlHQL33/7BxLib1TZvpd3WwQGecLGxgzpadn4aeVBnDqRpNJm7ARP9BvYCUbG+oi9kIZli8ORnqas6UOpU8Z+PgK+Qa/AyMwQsZGXsPydn5CeePOJ21jaWSBowWi85OsGPbkebiTexOLxP+Dy6WSxjb1zEwQteAMdPV2gpaOF1Lg0fO6/BLev36npQ6q1/Aa+iNeHdYWFhSESkzOx/Ic/cSkho9K2Ds1fwLiAnnBqYwMbG1N8v/Iv/LYjusp9jxrxP7w5wQu/bY/C96sO1tQh1EmD/NwxfERX8bXlu+UHkHCp8roDQC9PZ4wb7wkbG1OkpWXjpx8P49TJR68tBw9/XOl2IasO4tctJ6u9/3VFtY08eHl5YerUqdW1O6rHvF52waTJvbEh9CgmTViN5MRbWPDNSJiZyStt79K+KT6ZMxj798Rg0vifEHk0AZ/PHw6HFlZimxGju2GwfxcsW7wPk98MRcGDIiz4ZhR0G2mr67BqvREfDoLfe75Y9vaPeO9/s1BwvxDz938KXT3dKrcxMjPE0mNfoLS4FB/3m4egdu8jZPo65Cnvi21sW1rj26NfIDUhHdO85+At1+nY9OU2FBcUqeOwaiVvT2e889bLWLvxGCa+E4qk5Ex8PW9ElY9xPT0dZNzMwY9rFMjKuvfEfTs52mBg/05ITMqsia7XaV7ebTHp7Vewft0xTHpzDZKSMrFw0etVv7a0a4JPP/PDvvAYvDXxZ0Qeu4z/+8IfDg6PXlv8hyxTWRYt3IOyMgFHjySo67BqJUnhITAwEDKZ7LElMTGxpvqnVmvXroWZmZmmu/GY+fPno0uXLjA2Nkbjxo3h5+eHhIS6+8Ad+npXhP9+Fn+En0Nqyh0s/TochQXF6DugU6XthwzrgqiTSfg17ARSr2Vh7eoIJF7OwKChnSu0eQmb1h/D8WOXcTUpEwu/3A1LS2N07+mkpqOq/QZP6Y9NX23D37ujcfVCKhaO/R6Wdubo7telym1GzPTD7etZWDxhBRKiEnEzJROn/zyPjORbYptxX47EqfCzWD1zI5JiUpCRfAt//x6NnNt31XFYtdKwoS9h775z2H/gAq6lZuGbZftRUFiMfq92rLR9wuWbWPXTYRxSxKO4uLTK/Rro6+LTj17D4m/34d69gprqfp3lP+wlhO+NwR/7z+PatTtY+s0+FBaUoK+va6XthwztgqhTSfh1y0mkpmZhbegRXLlyE36D3cU2SuV9laV79zaIibmGjIwcNR1V7SR55KFv377IyMhQWVq0aFETfWvwiorKP7lFRETg3XffxYkTJ/Dnn3+iuLgYffr0wf379/9jD7WPjo4WHB1tcSb6qrhOEIAz0Slwadek0m1c2jdVaQ8AUSeT4dK+KQDA1s4Mli8Y40zUozb37xciPi5dbNPQ2bRoDEtbc5z964K4Lv9uPi6dTIRLt6oDVreBnXH5dBI+2/IBfr25GitPL4Jv0Cvi9TKZDF37v4i0Kzcwf98n+PXmaiz/ex48BlUdSOo7HR0tOLWxwemzKeI6QQBOn02BS9vKH+NPa8p7fXDiVBJOn732nL2sf8TXltMp4jpBAM6cuVr1a4tLE5yu0B4AoqOSq2xvbm6Irv9rjX3hMdXU67pLcnjQ09ODjY2NyqKt/fjQsFKpREBAAMzNzSGXy+Hr64srV64AAARBgJWVFX777TexfadOnWBraytePnbsGPT09JCfn//YvlesWIE2bdpAX18f1tbW8Pf3BwCsX78elpaWKCwsVGnv5+eHMWPGAADOnTsHb29vGBsbw8TEBO7u7oiOjoZCocC4ceOQm5srjqjMnTsXAFBYWIjp06ejSZMmMDQ0RNeuXaFQKMT9Pxyx2LNnD5ycnCCXy+Hv74/8/HysW7cODg4OMDc3R3BwMEpLq/5UMXfuXHTq1AmrV69GixYtoK+vDwDYv38/AgMD0a5dO7i6umLt2rVITU3F6dOnn3RX1UqmpnJo62hBma0afJTZ92BuaVTpNuYWRlAqVdvnKO/DwsJQvB7AE9s0dBY2ZgAA5a0clfXKWzkwtzarcjvblo0xcFIfpCdmYFbfL/H7qgN4d9l49A7wBACYNTaF3NgAI2b6IeqPGMx69UtE7jyFOdumo2Mvlxo6mtrN1EQObW0tZP/r8ah8zsfjy15t4djaGj/9rHjOHtZPpqbldf/368CT6m5RyWuLUnkfFuaVvxb1ebUD8vOLGvwpC6AGJ0wGBgbiypUr2L17N0xMTDBz5kz069cPcXFx0NXVRa9evaBQKODv7w+lUon4+HgYGBjg0qVLcHZ2RkREBLp06QK5XPVcVXR0NIKDg7FhwwZ4eHggOzsbR48eBQAMGzYMwcHB2L17N4YNGwYAyMzMxN69e3HgwAEAwOjRo+Hm5oaVK1dCW1sbMTEx0NXVhYeHB5YuXYrZs2eLpwSMjMofQJMnT0ZcXBw2b94MOzs77NixA3379sWFCxfQpk0bAEB+fj6WL1+OzZs3Iy8vD0OGDMHgwYNhZmaG8PBwJCcnY+jQoejevTtGjBhRZd0SExOxbds2bN++vdJQBgC5ubkAAAsLiyr3U1hYqBKi7t5tuEPIDdHLo3pg6qq3xMufDpj/TPuRaWnhcnQS1nwSBgBIikmBQ/tmGPBWH/y5PgJaWjIAwN+7orF96d7yNudS0K6bEwa81Rvnj8Q955EQAFhZGWPy2z6Y/tFmFD3htAbVrL6+rjj4V+wTTy01FJLDw549e8Q3VQDw9fXF1q1bVdo8DA2RkZHw8PAAAGzatAnNmjXDzp07MWzYMHh5eSEkJAQAcOTIEbi5ucHGxgYKhQLOzs5QKBTw9PR87PZTU1NhaGiIAQMGwNjYGM2bN4ebmxsAwMDAAKNGjUJoaKgYHjZu3Ah7e3t4eXmJ28+YMQPOzs4AIL75A4CpqSlkMhlsbGxUbi80NBSpqamws7MDAEyfPh379+9HaGgo5s2bBwAoLi7GypUr0apVKwCAv78/NmzYgFu3bsHIyAguLi7w9vbG4cOHnxgeioqKsH79elhZWVV6fVlZGaZOnYru3bujffv2Ve5n/vz5+Pzzz6u8XlNyc/NRWlIG8399EjC3MIKyioliyux7MDdXbW9mbojsf0YvlNnl25mbGyK7wj7MzA2RlHgLDdHfu6Nx6eSjuUi6euVPdXNrM2TfzBHXm1ubIelcSpX7yc5QIjU+TWVdanw6eg75HwAg904eSopLcC3+umqbS2lo3935OY+ibsq9m4/S0jJY/Osxa17hMSuVUxsbWJgb4qcV48R12tpa6NihGQYPckfv/l+jrEx4rn7Xdbm55XX/92vFk+qeXclri7m5IbKVj78WdejQDPb2lvji/3ZUX6frMMmnLby9vRETEyMuy5cvf6xNfHw8dHR00LVrV3GdpaUlnJycEB8fDwDw9PREXFwcbt++jYiICHh5ecHLywsKhQLFxcU4fvy4+IZfUe/evdG8eXO0bNkSY8aMwaZNm1RObUycOBEHDhxAeno6gPJTCg8negLABx98gKCgIPj4+GDBggVISkp67DYqunDhAkpLS+Ho6AgjIyNxiYiIUNlWLpeLwQEArK2t4eDgoBK0rK2tkZn55BnSzZs3rzI4AMC7776LixcvYvPmzU/cz6xZs5Cbmysu169ff2J7dSkpKcPlyxl40f3RPBmZDHBzd0BcbHql28RdTINbZweVde5dWiDuYvmbWsaNHGTdyVNpI5c3QluXJmKbhubBvQLcSLopLtfi0pCVoYTbK48Cp9zYAM5dWyPu76qHYGMjE9DU0U5lXVNHW9y6dhsAUFJcgoSoJDRzVD1H3KSNHW5da5hf0ywpKUPClZt4sZODuE4mA9w7NUdcfOWP8f9y+uw1jHtzNYLeXiMulxIy8NehWAS9vabBBwfg0WuL24sO4jqZDHB78QmvLXHpeLFCewBwd29RaXvffq5ISMhAMr/lAuAZwoOhoSFat24tLhXnKUjRoUMHWFhYICIiQiU8REREICoqCsXFxeKoRUXGxsY4c+YMwsLCYGtri9mzZ8PV1RU5OTkAADc3N7i6umL9+vU4ffo0YmNjERgYKG4/d+5cxMbGon///jh06BBcXFywY0fVSfLevXvQ1tbG6dOnVUJTfHw8li1bJrbT1VX9uptMJqt0XVlZ2RPrYmhY9TnRyZMnY8+ePTh8+DCaNn3yREA9PT2YmJioLLXFts0n0W+gG3r37Qj75paYMr0f9A10sX/vOQDAzE9fw4S3vMX227dGoUvXVvB/vSua2VsiYHwvODrbYde26AptTmH02B7o1r0NWrS0wsxPByErKw+RR3lu8qEdy/Zi1CdD0W1gZzi0t8eH6yYj64YSkTujxDaL/pyNQe/2FS9vW7oHbf/XBiNnDYZdKxt4j+yBfhN9sHvFfrHN1sW74TnCA75Br8CulQ0GvdsX3Qa6Y/fKP9R6fLXJ1m2nMKCfK17t3R72zSzxfvCr0NdvhH1/nAcAzJoxABPHPxpZ1dHRQuuWjdG6ZWPo6GrhhReM0bplYzSxMwMAPHhQhKspd1SWgoJi3L37AFdTGmZIq8xvW0+h/4BO6PNqB9jbW2Lq+77Q19fFH/vL6z5z1kBMCPIS22/fFoUuL7XEsGEvoVkzSwSM7QlHJ1vs3KE6n0wub4Rens4I3xujxqOp3WpkzkPbtm1RUlKCkydPigEgKysLCQkJcHEpn0Qlk8nQs2dP7Nq1C7GxsejRowfkcjkKCwsREhKCzp07V/lGqqOjAx8fH/j4+GDOnDkwMzPDoUOHMGTIEABAUFAQli5divT0dPj4+KBZs2Yq2zs6OsLR0RHvv/8+Ro4cidDQUAwePBiNGjV6bEKjm5sbSktLkZmZiZ49e1Z3qZ6KIAh47733sGPHDigUijr/7RbFoTiYmskRGOQJc4vyUwuzpoUh55+JS42tTVU+ScVdTMO8z3di3EQvjH/TG+lp2Zgz61ekXL0tttmy6W/o6zfC+x/2h5GRPi5euI6PpoWhuIjnJh/asmgX9A31MTXkLRiZyXHx2CXM8v0KxYXFYhvbVtYwecFYvHw5Oglzh3yNCfNG443P/HHzaiZWvr8Wh345JraJ3HkKy97+ESM/Gox3l41HWsINfO6/GLGRl9R6fLXJ4YhLMDOVY1xAT1iYl/9I1IefbIEyp3yU1LqxCQTh0WP8BUtjrF41Xrz8+rCueH1YV8ScS8XUGb+ovf91leJwPExN5QgM7FX+2pJ0Cx/N3CJOimzc2ARCxdeW2HR89eUujB/vifFBXkhPV2L2Z78hJeW2yn69X3aBTCbD4UOcw/OQTKj4CP4PgYGByMnJwc6dOx+7zsvLC506dcLSpUsBlH/D4cqVKwgJCYGxsTE++ugjJCYmihMmAWDZsmWYNm0aOnfujBMnTojb7dmzBzNmzMD8+eWTvJydnTF//nwMHjwYe/bsQXJyMnr16gVzc3OEh4dj8uTJOH/+PNq1awegfEKhnZ0dSkpKsH79enGOwYMHDzBjxgz4+/ujRYsWSEtLw9ixYzF06FAsXLgQx48fR/fu3fHXX3/B1dUVcrkccrkcb7zxBiIjI7FkyRK4ubnh9u3bOHjwIDp27Ij+/ftj7dq1mDp1qjj6AZSPcOzcuRMxMTFV1m/WrFlIT0/H+vXrq9wGAN555x388ssv2LVrF5ycHn2tztTUFAYGBk913929exempqbw7PoJdHT0n2oben6y4+c03YUGp9jH/b8bUbXSLn7yiCpVr5KSAhw59gVyc3M1NqpcY3/bIjQ0FO7u7hgwYAC6desGQRAQHh6uMpTv6emJ0tJSlbkNXl5ej61LSEgQv2FgZmaG7du34+WXX0bbtm2xatUqhIWFicEBKH9THTp0KIyMjODn5yeu19bWRlZWFgICAuDo6Ijhw4fD19dXnFjo4eGBSZMmYcSIEbCyssKiRYvEYwkICMC0adPg5OQEPz8/REVFwd7e/rlqlJGRgdTU1P9st3LlSuTm5sLLywu2trbismXLlue6fSIiomchaeShLnnllVfQrl27Sid0NkQcedAMjjyoH0ce1I8jD+pVG0Ye6t0fxlIqlVAoFFAoFFixYoWmu0NERFTv1Lvw4ObmBqVSiYULF6rMDyAiIqLqUe/CQ0pKiqa7QEREVK/V2IRJIiIiqp8YHoiIiEgShgciIiKShOGBiIiIJGF4ICIiIkkYHoiIiEgShgciIiKShOGBiIiIJGF4ICIiIkkYHoiIiEgShgciIiKShOGBiIiIJGF4ICIiIkkYHoiIiEgShgciIiKShOGBiIiIJGF4ICIiIkkYHoiIiEgShgciIiKShOGBiIiIJGF4ICIiIkkYHoiIiEgShgciIiKShOGBiIiIJGF4ICIiIkkYHoiIiEgShgciIiKShOGBiIiIJGF4ICIiIkkYHoiIiEgShgciIiKShOGBiIiIJGF4ICIiIkkYHoiIiEgShgciIiKShOGBiIiIJNHRdAeI6jOdpk003YUGp6y4TNNdaHhYcvWqBfXmyAMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCSJjqY7QA3Ta0PcMXxkN1hYGCEp6Ra+//YPJMTfqLJ9L++2CAzyhI2NGdLTsvHTyoM4dSJJpc3YCZ7oN7ATjIz1EXshDcsWhyM9TVnTh1KnjPnAF31H/Q+GJgaIi76K7z/eihspd6ps3/+N7ug/pjusm1oAAK5dvolflv2BaEW82Gbhlsno2K21ynZ7N0bi+4+31sxB1CGD/NwxfERX8XH+3fIDSLiUUWX7Xp7OGDfeEzY2pkhLy8ZPPx7GqZOPHucHD39c6XYhqw7i1y0nq73/dc0gP3cMf71CvZf9R729KtQ7PRs/rVKtNwDYN7fExLe80dHVHtraWrh27Q4+/2w7MjPv1vTh1GpqGXnw8vLC1KlT1XFT9dbcuXPRqVMnTXejWni97IJJk3tjQ+hRTJqwGsmJt7Dgm5EwM5NX2t6lfVN8Mmcw9u+JwaTxPyHyaAI+nz8cDi2sxDYjRnfDYP8uWLZ4Hya/GYqCB0VY8M0o6DbSVtdh1XrD3n4Fr43rhe9mbcXU175FQX4Rvtw4Cbp6VX+GuHMzB6ELfsd7/RcjeMASnDt+GbNXT4C9o41Ku32/HMco98/EZc283TV9OLWel3dbTHr7FaxfdwyT3lyDpKRMLFz0etWP83ZN8OlnftgXHoO3Jv6MyGOX8X9f+MPB4dHj3H/IMpVl0cI9KCsTcPRIgroOq9by8m6LSe/+U++J/9R7sYR6H72M//vKX+V1xdbODMu+G4PrqVmYNnUTJo5fjY3rIlFUVKKuw6q1qi08BAYGQiaTPbYkJiZW101o1Nq1a2FmZqbpbtQLQ1/vivDfz+KP8HNITbmDpV+Ho7CgGH0HdKq0/ZBhXRB1Mgm/hp1A6rUsrF0dgcTLGRg0tHOFNi9h0/pjOH7sMq4mZWLhl7thaWmM7j2d1HRUtZ/fhF7Y/N0BnPjzIlIuZWDx+5tg2dgUHn06VLnNyb9iEXU4HjdS7iD96m2s+zocBfmFcHZrrtKu8EExlLfzxCX/XmFNH06t5z/sJYTvjcEf+8/j2rU7WPrNPhQWlKCvr2ul7YcM7YKoU0n4dctJpKZmYW3oEVy5chN+g93FNkrlfZWle/c2iIm5hoyMHDUdVe3lP/wlhO+JwR/7/qn3kn/q3a+Kevv/U+/NJ8tfV9YcwZXLqvWeEOSFkyeT8OOqw0i8cgsZN3Lw9/EryMnJV9dh1VrVOvLQt29fZGRkqCwtWrSozpugOk5HRwuOjrY4E31VXCcIwJnoFLi0a1LpNi7tm6q0B4Cok8lwad8UQPmnA8sXjHEm6lGb+/cLER+XLrZp6GzsLWHR2BRnj10W1+XnFSAh5hqc3R2eah9aWjJ4DnSDvoEeLp1JUbnO288dm2O+xMo/ZyJw5gDo6etWY+/rHvFxfjpFXCcIwJkzV6t+nLs0wekK7QEgOiq5yvbm5obo+r/W2BceU029rruqrPfpJ9S73ZPrLZMBXbu1Qtr1bCz4+nX8tnMKvl85Ft17ONbUYdQp1Roe9PT0YGNjo7Joaz8+bKxUKhEQEABzc3PI5XL4+vriypUrAABBEGBlZYXffvtNbN+pUyfY2tqKl48dOwY9PT3k5z+e/lasWIE2bdpAX18f1tbW8Pf3BwCsX78elpaWKCxU/UTk5+eHMWPGAADOnTsHb29vGBsbw8TEBO7u7oiOjoZCocC4ceOQm5srjqjMnTsXAFBYWIjp06ejSZMmMDQ0RNeuXaFQKMT9Pxyx2LNnD5ycnCCXy+Hv74/8/HysW7cODg4OMDc3R3BwMEpLS5+61klJSWjZsiUmT54MQRCeejtNMzWVQ1tHC8rs+yrrldn3YG5pVOk25hZGUCpV2+co78PCwlC8HsAT2zR05lbGAADlnTyV9co7eTC3Mnnitg5OttgevxC7Exdj8rzh+OLNn5F65ZZ4vWLXaSyashEfjfgBv/7wF14Z0hkzlr1R/QdRh5iayqGtrfXYY1L5hMekRSWPc6XyPizMK39e9Hm1A/Lzi3jKAhVeV6qj3v+8npiZG0Iu18Pro7oh6lQSZk4Pw7GjlzH3i6Ho6GpfMwdSh2hkwmRgYCCuXLmC3bt3w8TEBDNnzkS/fv0QFxcHXV1d9OrVCwqFAv7+/lAqlYiPj4eBgQEuXboEZ2dnREREoEuXLpDLVc9lRUdHIzg4GBs2bICHhweys7Nx9OhRAMCwYcMQHByM3bt3Y9iwYQCAzMxM7N27FwcOHAAAjB49Gm5ubli5ciW0tbURExMDXV1deHh4YOnSpZg9ezYSEsqfqEZG5Q+wyZMnIy4uDps3b4adnR127NiBvn374sKFC2jTpg0AID8/H8uXL8fmzZuRl5eHIUOGYPDgwTAzM0N4eDiSk5MxdOhQdO/eHSNGjPjP+p0/fx6vvvoqJkyYgC+//LLSNoWFhSpB6e7dhj25p6Hx9nPHe/OHi5fnBP74zPtKS87Eu32/hqGJPnr064Rp34zGh8O/EwPEvl/+FtumJGQgO/MuFmx+F7bNLZFxLevZD4KeqK+vKw7+FYvi4qf/0EFPT0smAwAcj7yCbVujAABJiZlo174JBg5yw/lzqZrsnsZVa3jYs2eP+KYKAL6+vti6VXXG9cPQEBkZCQ8PDwDApk2b0KxZM+zcuRPDhg2Dl5cXQkJCAABHjhyBm5sbbGxsoFAo4OzsDIVCAU9Pz8duPzU1FYaGhhgwYACMjY3RvHlzuLm5AQAMDAwwatQohIaGiuFh48aNsLe3h5eXl7j9jBkz4OzsDADimz8AmJqaQiaTwcbGRuX2QkNDkZqaCjs7OwDA9OnTsX//foSGhmLevHkAgOLiYqxcuRKtWrUCAPj7+2PDhg24desWjIyM4OLiAm9vbxw+fPg/w8Px48cxYMAAfPLJJ5g2bVqV7ebPn4/PP//8ifvShNzcfJSWlMH8X58GzC2MoMy6V+k2yux7MDdXbW9mbojsf0YvlNnl25mbGyK7wj7MzA2RlHgLDdGJPy/i0tlr4uWHkyLNXzCGssIscfMXjJEUl/7EfZUUlyLjWvk3MhIvpMHRtRkGjffEd7N+rbT9w9u1bW7VYMNDbm4+SkvLHnvcmld43P5bdiWPc3NzQ2QrH39edOjQDPb2lvji/3ZUX6frMPF1pTrq/c/rSW5uPkpKSnHtX99GSr2WhfYdeDq0Wk9beHt7IyYmRlyWL1/+WJv4+Hjo6Oiga9eu4jpLS0s4OTkhPr7861+enp6Ii4vD7du3ERERAS8vL3h5eUGhUKC4uBjHjx8X3/Ar6t27N5o3b46WLVtizJgx2LRpk8qpjYkTJ+LAgQNITy9/sVy7dq040RMAPvjgAwQFBcHHxwcLFixAUlLSY7dR0YULF1BaWgpHR0cYGRmJS0REhMq2crlcDA4AYG1tDQcHB5WgZW1tjczMzCfeXmpqKnr37o3Zs2c/MTgAwKxZs5Cbmysu169ff2J7dSkpKcPlyxl40f3RXBiZDHBzd0BcbOVvYnEX0+DW2UFlnXuXFoi7mAYAyLiRg6w7eSpt5PJGaOvSRGzT0Dy4X4iMa3fEJfXyTWRn5qJT90eBWG6kB6dOzXHpX+d9/4tMJoNuo6o/d7T655xxdmbuM/W9Pnj4OHd70UFcJ5MBbi8+4XEel44XK7QHAHf3FpW29+3nioSEDCQnPfk1o6EQ611h/s5/1js2HS/+a76Pe+dH9S4pKUPCpQw0s7dQadO0mQVu3eJIbrWGB0NDQ7Ru3VpcKs5TkKJDhw6wsLBARESESniIiIhAVFQUiouLxVGLioyNjXHmzBmEhYXB1tYWs2fPhqurK3JycgAAbm5ucHV1xfr163H69GnExsYiMDBQ3H7u3LmIjY1F//79cejQIbi4uGDHjqqT/b1796CtrY3Tp0+rhKb4+HgsW7ZMbKerqzp5TCaTVbqurKzsiXWxsrLCSy+9hLCwsP88DaGnpwcTExOVpbbYtvkk+g10Q+++HWHf3BJTpveDvoEu9u89BwCY+elrmPCWt9h++9YodOnaCv6vd0Uze0sEjO8FR2c77NoWXaHNKYwe2wPdurdBi5ZWmPnpIGRl5SHyKM8HP7Tz5yN4PbgPuvZuBwcnW0z79g1kZebi+IELYpv5Ye9g4Nge4uXAmQPQ/qWWaNzUAg5OtgicOQAdu7XG4Z3ltbdtbomRwX3QukNTNG5qga6922H6t6Nx4UQiUp7w/fqG4Letp9B/QCf0ebUD7O0tMfV9X+jr6+KP/ecBADNnDcSEIC+x/fZtUejyUksMG/YSmjWzRMDYnnB0ssXOHadV9iuXN0IvT2eE741R49HUfr/9egr9+/9T7+aWmPqBL/QNdPHHvn/q/fFATJjoJbbf/ts/9R7+UvnrSuDj9d6y+QS8vF3Qb0An2DUxx6DB7ujWrQ127zz975tvcNQ+56Ft27YoKSnByZMnxQCQlZWFhIQEuLi4ACh/I+3Zsyd27dqF2NhY9OjRA3K5HIWFhQgJCUHnzp1haFj5JBgdHR34+PjAx8cHc+bMgZmZGQ4dOoQhQ4YAAIKCgrB06VKkp6fDx8cHzZo1U9ne0dERjo6OeP/99zFy5EiEhoZi8ODBaNSo0WMTGt3c3FBaWorMzEz07Nmzukv1GAMDA+zZswf9+vXDq6++igMHDsDY2LjGb7e6KQ7FwdRMjsAgT5hblJ9amDUtDDn/TF5qbG2KsrJHk0DjLqZh3uc7MW6iF8a/6Y30tGzMmfUrUq7eFtts2fQ39PUb4f0P+8PISB8XL1zHR9PCUFzE88EPbV15EPoGjRA8fwSMTAwQG52Mz8aEoLjw0XfWbe1fgInFoxExM0sjTP/2DVg0NsH9vAe4eukGPh2zCmePln9ro7ioFG49HOE3wRP6Bo1wOyMHx/adw+blB9R+fLWN4nA8TE3lCAzsVf44T7qFj2ZuESfpNW5sAqHi4zw2HV99uQvjx3tifJAX0tOVmP3Zb0hJua2yX++XXSCTyXD4UJxaj6e2UxyOL39dGd9LfF35aMZ/1PuLXRg/wRPjJ3ohPU2J2Z/8pvK6Enn0MpZ+sw8jR3tgcnBvXE/NxtzZ23DxQsMc0axIJlTTVP3AwEDk5ORg586dj13n5eWFTp06YenSpQDKv+Fw5coVhISEwNjYGB999BESExPFCZMAsGzZMkybNg2dO3fGiRMnxO327NmDGTNmYP78+QAAZ2dnzJ8/H4MHD8aePXuQnJyMXr16wdzcHOHh4Zg8eTLOnz+Pdu3aAQByc3NhZ2eHkpISrF+/Xpxj8ODBA8yYMQP+/v5o0aIF0tLSMHbsWAwdOhQLFy7E8ePH0b17d/z1119wdXWFXC6HXC7HG2+8gcjISCxZsgRubm64ffs2Dh48iI4dO6J///5Yu3Ytpk6dKo5+AOUjHDt37kRMTEyV9Zs1axbS09Oxfv36x7a5d+8efH19IQgC9u/fr3L6oyp3796FqakpPLt+Ah0d/ae+X+n56KZW/euNVDOKWjXWdBcanicPmlI1KykpwJHjXyA3N1djo8oa+dsWoaGhcHd3x4ABA9CtWzcIgoDw8HCVoXxPT0+UlpaqzG3w8vJ6bF1CQgJyc8vPrZqZmWH79u14+eWX0bZtW6xatQphYWFicADKJz4OHToURkZG8PPzE9dra2sjKysLAQEBcHR0xPDhw+Hr6ytOOvTw8MCkSZMwYsQIWFlZYdGiReKxBAQEYNq0aXBycoKfnx+ioqJgb/98X+XJyMhAamrls3mNjIywb98+CIKA/v374/79yicEERER1YRqG3moS1555RW0a9eu0gmd9RVHHjSDIw/qx5EHDeDIg1rVhpGHBvWHsZRKJRQKBRQKBVasWKHp7hAREdVJDSo8uLm5QalUYuHChXBy4t88ICIiehYNKjykpKRougtERER1nkYmTBIREVHdxfBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQMD0RERCQJwwMRERFJwvBAREREkjA8EBERkSQ6mu4AqYcgCACAkpJCDfekYZGVsd7qVlJSoOkuNDxlmu5Aw/Lwdfzh67omyARN3jqpTVpaGpo1a6bpbhARUTW5fv06mjZtqpHbZnhoIMrKynDjxg0YGxtDJpNpujuS3L17F82aNcP169dhYmKi6e40CKy5+rHm6ldXay4IAvLy8mBnZwctLc3MPuBpiwZCS0tLYwm1upiYmNSpJ3h9wJqrH2uufnWx5qamphq9fU6YJCIiIkkYHoiIiEgShgeq9fT09DBnzhzo6elpuisNBmuufqy5+rHmz44TJomIiEgSjjwQERGRJAwPREREJAnDAxEREUnC8EBERESSMDwQERGRJAwPREREJAnDAxEREUnC8EBERESS/D/Ubwe9mgA93QAAAABJRU5ErkJggg==",
       "text/plain": [
        "<Figure size 480x480 with 1 Axes>"
       ]
@@ -396,7 +391,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -404,9 +399,9 @@
      "output_type": "stream",
      "text": [
       "Flow.system.m: 0.022\n",
-      "Flow.system.r: 1.810\n",
-      "Flow.system.r2: 0.378\n",
-      "Flow.system.k: 0.241\n"
+      "Flow.system.r: 1.785\n",
+      "Flow.system.r2: 0.372\n",
+      "Flow.system.k: 0.235\n"
      ]
     }
    ],
diff --git a/tests/test_estimation.py b/tests/test_estimation.py
index 5197bc2..d19aee5 100644
--- a/tests/test_estimation.py
+++ b/tests/test_estimation.py
@@ -19,26 +19,27 @@
 from dynax.example_models import LotkaVolterra, NonlinearDrag, SpringMassDamper
 
 
-tols = dict(rtol=1e-05, atol=1e-05)
+tols = dict(rtol=1e-02, atol=1e-04)
 
 
 @pytest.mark.parametrize("outputs", [[0], [0, 1]])
 def test_fit_least_squares(outputs):
     # data
-    t = np.linspace(0, 2, 200)
+    t = np.linspace(0, 1, 100)
     u = (
-        np.sin(1 * 2 * np.pi * t)
+        0.1 * np.sin(1 * 2 * np.pi * t)
         + np.sin(0.1 * 2 * np.pi * t)
         + np.sin(10 * 2 * np.pi * t)
     )
-    x0 = jnp.array([1.0, 0.0])
-    true_model = Flow(NonlinearDrag(1.0, 2.0, 3.0, 4.0, outputs))
-    _, y_true = true_model(t, u, x0)
+    true_model = Flow(
+        NonlinearDrag(1.0, 2.0, 3.0, 4.0, outputs),
+    )
+    _, y_true = true_model(t, u)
     # fit
-    init_model = Flow(NonlinearDrag(1.0, 1.0, 1.0, 1.0, outputs))
-    pred_model = fit_least_squares(init_model, t, y_true, x0, u).result
+    init_model = Flow(NonlinearDrag(1.0, 2.0, 3.0, 4.0, outputs))
+    pred_model = fit_least_squares(init_model, t, y_true, u, verbose=2).result
     # check result
-    _, y_pred = pred_model(t, u, x0)
+    _, y_pred = pred_model(t, u)
     npt.assert_allclose(y_pred, y_true, **tols)
     npt.assert_allclose(
         jax.tree_util.tree_flatten(pred_model)[0],
@@ -49,7 +50,7 @@ def test_fit_least_squares(outputs):
 
 def test_fit_least_squares_on_batch():
     # data
-    t = np.linspace(0, 2, 200)
+    t = np.linspace(0, 1, 100)
     us = np.stack(
         (
             np.sin(1 * 2 * np.pi * t),
@@ -58,16 +59,18 @@ def test_fit_least_squares_on_batch():
         ),
         axis=0,
     )
-    x0 = np.array([1.0, 0.0])
-    x0s = np.repeat(x0[None], us.shape[0], axis=0)
     ts = np.repeat(t[None], us.shape[0], axis=0)
-    true_model = Flow(NonlinearDrag(1.0, 2.0, 3.0, 4.0))
-    _, ys = jax.vmap(true_model)(ts, us, x0s)
+    true_model = Flow(
+        NonlinearDrag(1.0, 2.0, 3.0, 4.0),
+    )
+    _, ys = jax.vmap(true_model)(ts, us)
     # fit
-    init_model = Flow(NonlinearDrag(1.0, 1.0, 1.0, 1.0))
-    pred_model = fit_least_squares(init_model, ts, ys, x0s, us, batched=True).result
+    init_model = Flow(
+        NonlinearDrag(1.0, 2.0, 3.0, 4.0),
+    )
+    pred_model = fit_least_squares(init_model, ts, ys, us, batched=True).result
     # check result
-    _, ys_pred = jax.vmap(pred_model)(ts, us, x0s)
+    _, ys_pred = jax.vmap(pred_model)(ts, us)
     npt.assert_allclose(ys_pred, ys, **tols)
     npt.assert_allclose(
         jax.tree_util.tree_flatten(pred_model)[0],
@@ -80,7 +83,9 @@ def test_can_compute_jacfwd_with_implicit_methods():
     # don't get catched by https://github.com/patrick-kidger/diffrax/issues/135
     t = jnp.linspace(0, 1, 10)
     x0 = jnp.array([1.0, 0.0])
-    solver_opt = dict(solver=Kvaerno5(), step=PIDController(atol=1e-6, rtol=1e-3))
+    solver_opt = dict(
+        solver=Kvaerno5(), stepsize_controller=PIDController(atol=1e-6, rtol=1e-3)
+    )
 
     def fun(m, r, k, x0=x0, solver_opt=solver_opt, t=t):
         model = Flow(SpringMassDamper(m, r, k), **solver_opt)
@@ -94,19 +99,18 @@ def fun(m, r, k, x0=x0, solver_opt=solver_opt, t=t):
 def test_fit_with_bounded_parameters():
     # data
     t = jnp.linspace(0, 1, 100)
-    x0 = jnp.array([0.5, 0.5])
-    solver_opt = dict(step=PIDController(rtol=1e-5, atol=1e-7))
+    solver_opt = dict(stepsize_controller=PIDController(rtol=1e-5, atol=1e-7))
     true_model = Flow(
         LotkaVolterra(alpha=2 / 3, beta=4 / 3, gamma=1.0, delta=1.0), **solver_opt
     )
-    x_true, _ = true_model(t, initial_state=x0)
+    x_true, _ = true_model(t)
     # fit
     init_model = Flow(
         LotkaVolterra(alpha=1.0, beta=1.0, gamma=1.5, delta=2.0), **solver_opt
     )
-    pred_model = fit_least_squares(init_model, t, x_true, x0).result
+    pred_model = fit_least_squares(init_model, t, x_true).result
     # check result
-    x_pred, _ = pred_model(t, initial_state=x0)
+    x_pred, _ = pred_model(t)
     npt.assert_allclose(x_pred, x_true, **tols)
     npt.assert_allclose(
         jax.tree_util.tree_flatten(pred_model)[0],
@@ -134,7 +138,7 @@ def vector_field(self, x, u=None, t=None):
 
     # data
     t = jnp.linspace(0, 1, 100)
-    solver_opt = dict(step=PIDController(rtol=1e-5, atol=1e-7))
+    solver_opt = dict(stepsize_controller=PIDController(rtol=1e-5, atol=1e-7))
     true_model = Flow(
         LotkaVolterraBounded(
             alpha=2 / 3, beta=4 / 3, delta_gamma=jnp.array([1.0, 1.0])
@@ -159,25 +163,23 @@ def vector_field(self, x, u=None, t=None):
 @pytest.mark.parametrize("num_shots", [1, 2, 3])
 def test_fit_multiple_shooting_with_input(num_shots):
     # data
-    t = jnp.linspace(0, 10, 10000)
+    t = jnp.linspace(0, 1, 200)
     u = jnp.sin(1 * 2 * np.pi * t)
-    x0 = jnp.array([1.0, 0.0])
     true_model = Flow(SpringMassDamper(1.0, 2.0, 3.0))
-    x_true, _ = true_model(t, u, initial_state=x0)
+    x_true, _ = true_model(t, u)
     # fit
     init_model = Flow(SpringMassDamper(1.0, 1.0, 1.0))
     pred_model = fit_multiple_shooting(
         init_model,
         t,
         x_true,
-        x0,
         u,
         continuity_penalty=1,
         num_shots=num_shots,
         verbose=2,
     ).result
     # check result
-    x_pred, _ = pred_model(t, u, initial_state=x0)
+    x_pred, _ = pred_model(t, u)
     npt.assert_allclose(x_pred, x_true, **tols)
     npt.assert_allclose(
         jax.tree_util.tree_flatten(pred_model)[0],
@@ -189,22 +191,21 @@ def test_fit_multiple_shooting_with_input(num_shots):
 @pytest.mark.parametrize("num_shots", [1, 2, 3])
 def test_fit_multiple_shooting_without_input(num_shots):
     # data
-    t = jnp.linspace(0, 1, 1000)
-    x0 = jnp.array([0.5, 0.5])
-    solver_opt = dict(step=PIDController(rtol=1e-3, atol=1e-6))
+    t = jnp.linspace(0, 1, 200)
+    solver_opt = dict(stepsize_controller=PIDController(rtol=1e-3, atol=1e-6))
     true_model = Flow(
         LotkaVolterra(alpha=2 / 3, beta=4 / 3, gamma=1.0, delta=1.0), **solver_opt
     )
-    x_true, _ = true_model(t, initial_state=x0)
+    x_true, _ = true_model(t)
     # fit
     init_model = Flow(
         LotkaVolterra(alpha=1.0, beta=1.0, gamma=1.5, delta=2.0), **solver_opt
     )
     pred_model = fit_multiple_shooting(
-        init_model, t, x_true, x0, num_shots=num_shots, continuity_penalty=1
+        init_model, t, x_true, num_shots=num_shots, continuity_penalty=1
     ).result
     # check result
-    x_pred, _ = pred_model(t, initial_state=x0)
+    x_pred, _ = pred_model(t)
     npt.assert_allclose(x_pred, x_true, atol=1e-3, rtol=1e-3)
     npt.assert_allclose(
         jax.tree_util.tree_flatten(pred_model)[0],
@@ -228,15 +229,14 @@ def test_csd_matching():
     np.random.seed(123)
     # model
     sys = SpringMassDamper(1.0, 1.0, 1.0)
-    model = Flow(sys, step=PIDController(rtol=1e-4, atol=1e-6))
-    x0 = np.zeros(jnp.shape(sys.initial_state))
+    model = Flow(sys, stepsize_controller=PIDController(rtol=1e-4, atol=1e-6))
     # input
     duration = 1000
     sr = 50
     t = np.arange(int(duration * sr)) / sr
     u = np.random.normal(size=len(t))
     # output
-    _, y = model(t, u, initial_state=x0)
+    _, y = model(t, u)
     # fit
     init_sys = SpringMassDamper(1.0, 1.0, 1.0)
     fitted_sys = fit_csd_matching(init_sys, u, y, sr, nperseg=1024, verbose=1).result
diff --git a/tests/test_evolution.py b/tests/test_evolution.py
index 98ea8fd..a994952 100644
--- a/tests/test_evolution.py
+++ b/tests/test_evolution.py
@@ -44,7 +44,7 @@ def x(t, x0, dx0):
 
     x0 = jnp.array([1, 0])  # x(t=0)=1, dx(t=0)=0
     t = jnp.linspace(0, 1)
-    model = Flow(sys, step=dfx.PIDController(rtol=1e-7, atol=1e-9))
+    model = Flow(sys, stepsize_controller=dfx.PIDController(rtol=1e-7, atol=1e-9))
     x_pred = model(t, initial_state=x0)[1]
     x_true = x(t, *x0)
     assert np.allclose(x_true, x_pred)
@@ -70,7 +70,7 @@ def x(t, x0, dx0, uconst):
     x0 = jnp.array([1, 0])  # x(t=0)=1, dx(t=0)=0
     t = jnp.linspace(0, 1)
     u = jnp.ones(t.shape + (1,)) * uconst
-    model = Flow(sys, step=dfx.PIDController(rtol=1e-7, atol=1e-9))
+    model = Flow(sys, stepsize_controller=dfx.PIDController(rtol=1e-7, atol=1e-9))
     x_pred = model(t, u, initial_state=x0)[1]
     x_true = x(t, x0[0], x0[1], uconst)
     assert np.allclose(x_true, x_pred)

From 855a11d616e9847cbd249bb521d1ee72bdf3ff20 Mon Sep 17 00:00:00 2001
From: fhchl <fhchl@users.noreply.github.com>
Date: Sun, 11 Feb 2024 15:00:28 +0100
Subject: [PATCH 09/10] add example for estimating initial state

---
 examples/fit_initial_state.py | 96 +++++++++++++++++++++++++++++++++++
 1 file changed, 96 insertions(+)
 create mode 100644 examples/fit_initial_state.py

diff --git a/examples/fit_initial_state.py b/examples/fit_initial_state.py
new file mode 100644
index 0000000..52d8e6d
--- /dev/null
+++ b/examples/fit_initial_state.py
@@ -0,0 +1,96 @@
+"""Example: fit a second-order nonlinear system to data."""
+
+
+import jax.numpy as jnp
+import matplotlib.pyplot as plt
+import numpy as np
+
+from dynax import ControlAffine, fit_csd_matching, fit_least_squares, Flow, free_field
+
+
+# Define a dynamical system of the form
+#
+# ẋ = f(x) + g(x)u
+# y = h(x)
+#
+# The `ControlAffine` class inherits from eqinox.Module which inherits from
+# `dataclasses.dataclass`.
+class NonlinearDrag(ControlAffine):
+    """Spring-mass-damper system with nonliner drag.
+
+    .. math:: m ẍ +  r ẋ + r2 ẋ |ẋ| + k x = u
+              y = x
+
+    """
+
+    # Declare parameters as dataclass fields.
+    m: float
+    r: float
+    r2: float
+    k: float
+
+    # The initial_state attribute is static by default. If we want to make it learnable
+    # we must declare it using the `free_field` function.
+    initial_state: jnp.ndarray = free_field(init=True)
+
+    n_inputs = "scalar"
+
+    # Define the dynamical system via the methods f, g, and h
+    def f(self, x):
+        x1, x2 = x
+        return jnp.array(
+            [x2, (-self.r * x2 - self.r2 * jnp.abs(x2) * x2 - self.k * x1) / self.m]
+        )
+
+    def g(self, x):
+        return jnp.array([0.0, 1.0 / self.m])
+
+    def h(self, x):
+        return x[0]
+
+
+# initiate a dynamical system representing the some "true" parameters
+true_system = NonlinearDrag(
+    m=1.0, r=2.0, r2=0.1, k=4.0, initial_state=jnp.array([1.0, 1.0])
+)
+# combine ODE system with ODE solver (Dopri5 and constant stepsize by default)
+true_model = Flow(true_system)
+print("true system:", true_system)
+
+# some training data using the true model. This could be your measurement data.
+t_train = np.linspace(0, 10, 1000)
+samplerate = 1 / t_train[1]
+np.random.seed(42)
+u_train = np.random.normal(size=len(t_train))
+x_train, y_train = true_model(t_train, u_train)
+
+# create our model system with some initial parameters
+initial_sys = NonlinearDrag(
+    m=1.0, r=1.0, r2=1.0, k=1.0, initial_state=jnp.array([0.0, 0.0])
+)
+print("initial system:", initial_sys)
+
+# If we have long-duration, wide-band input data we can fit the linear
+# parameters by matching the transfer-functions. In this example the result is
+# not very good.
+initial_sys = fit_csd_matching(
+    initial_sys, u_train, y_train, samplerate, nperseg=100
+).result
+print("linear params fitted:", initial_sys)
+
+# Combine the ODE with an ODE solver
+init_model = Flow(initial_sys)
+# Fit all parameters with previously estimated parameters as a starting guess.
+pred_model = fit_least_squares(
+    model=init_model, t=t_train, y=y_train, u=u_train, verbose=0
+).result
+print("fitted system:", pred_model.system)
+
+# check the results
+x_pred, y_pred = pred_model(t_train, u_train)
+assert np.allclose(x_train, x_pred)
+
+plt.plot(t_train, x_train, label="target")
+plt.plot(t_train, x_pred, "--", label="prediction")
+plt.legend()
+plt.show()

From f93ee877c906c9c88cfa13974c63ac48917f55a1 Mon Sep 17 00:00:00 2001
From: fhchl <fhchl@users.noreply.github.com>
Date: Sun, 11 Feb 2024 15:00:39 +0100
Subject: [PATCH 10/10] fix typo

---
 dynax/system.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dynax/system.py b/dynax/system.py
index 2dbf60b..89d1451 100644
--- a/dynax/system.py
+++ b/dynax/system.py
@@ -49,7 +49,7 @@ def boxed_field(lower: float, upper: float, **kwargs):
 
 
 def free_field(**kwargs):
-    """Remove the value constrained from attribute, e.g. when subclassing."""
+    """Remove the value constraint from attribute, e.g. when subclassing."""
     try:
         metadata = dict(kwargs["metadata"])
     except KeyError: