edmkit 0.0.13__tar.gz → 0.0.14__tar.gz

{edmkit-0.0.13 → edmkit-0.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: edmkit
-Version: 0.0.13
+Version: 0.0.14
 Summary: Simple EDM (Empirical Dynamic Modeling) library
 Author: FUJISHIGE TEMMA
 Author-email: FUJISHIGE TEMMA <tenma.x0@gmail.com>

{edmkit-0.0.13 → edmkit-0.0.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "edmkit"
-version = "0.0.13"
+version = "0.0.14"
 description = "Simple EDM (Empirical Dynamic Modeling) library"
 readme = "README.md"
 requires-python = ">= 3.13"
@@ -20,6 +20,7 @@ email = "tenma.x0@gmail.com"
 dev = [
     "griffe2md>=1.5.0",
     "hypothesis>=6.151.9",
+    "matplotlib>=3.11.2",
     "pytest>=9.1.1",
     "ruff>=0.15.20",
     "ty>=0.0.56",

{edmkit-0.0.13 → edmkit-0.0.14}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "edmkit"
-version = "0.0.13"
+version = "0.0.14"
 description = "Simple EDM (Empirical Dynamic Modeling) library"
 authors = [{ name = "FUJISHIGE TEMMA", email = "tenma.x0@gmail.com" }]
 readme = "README.md"
@@ -17,6 +17,7 @@ dependencies = [
 dev = [
     "griffe2md>=1.5.0",
     "hypothesis>=6.151.9",
+    "matplotlib>=3.11.2",
     "pytest>=9.1.1",
     "ruff>=0.15.20",
     "ty>=0.0.56",

edmkit-0.0.14/src/edmkit/generate/__init__.py

@@ -0,0 +1,10 @@
+from .ctrnn import ctrnn
+from .double_pendulum import double_pendulum, to_xy
+from .duffing import duffing
+from .lorenz import lorenz
+from .lorenz96 import lorenz96
+from .mackey_glass import mackey_glass
+from .rk45 import rk45
+from .rossler import rossler
+
+__all__ = ["ctrnn", "double_pendulum", "duffing", "lorenz", "lorenz96", "mackey_glass", "rk45", "rossler", "to_xy"]

edmkit-0.0.14/src/edmkit/generate/ctrnn.py

@@ -0,0 +1,25 @@
+import numpy as np
+
+__all__ = ["ctrnn"]
+
+
+def ctrnn(g: float, J: np.ndarray):
+    """Vector field of a continuous-time recurrent neural network ``dx/dt = -x + g J tanh(x)``.
+
+    Parameters
+    ----------
+    g : float
+        Gain (chaos for ``g > 1`` when ``J`` is large and random with variance ``1 / N``).
+    J : np.ndarray
+        Connectivity of shape ``(N, N)``; ``J[i, j]`` is the weight with which unit ``j`` drives unit ``i``.
+
+    Returns
+    -------
+    f : Callable[[float, np.ndarray], np.ndarray]
+        Right-hand side ``f(t, x)`` for a state of shape ``(N,)``.
+    """
+
+    def f(t: float, x: np.ndarray):
+        return -x + g * J @ np.tanh(x)
+
+    return f

{edmkit-0.0.13 → edmkit-0.0.14}/src/edmkit/generate/double_pendulum.py

@@ -3,17 +3,8 @@ import numpy as np
 __all__ = ["double_pendulum", "to_xy"]
 
 
-def double_pendulum(
-    m1: float,
-    m2: float,
-    L1: float,
-    L2: float,
-    g: float,
-    X0: np.ndarray,
-    dt: float,
-    t_max: int,
-):
-    """Generate double pendulum dynamics via forward Euler integration.
+def double_pendulum(m1: float, m2: float, L1: float, L2: float, g: float):
+    """Vector field of the double pendulum.
 
     Parameters
     ----------
@@ -27,22 +18,14 @@ def double_pendulum(
         Length of second pendulum.
     g : float
         Gravitational acceleration.
-    X0 : np.ndarray
-        Initial state ``(theta1, theta2, omega1, omega2)`` of shape ``(4,)``.
-    dt : float
-        Integration time step.
-    t_max : int
-        Maximum time.
 
     Returns
     -------
-    t : np.ndarray
-        Time array.
-    X : np.ndarray
-        State trajectory of shape ``(N, 4)``.
+    f : Callable[[float, np.ndarray], np.ndarray]
+        Right-hand side ``f(t, x)`` for a state ``(theta1, theta2, omega1, omega2)`` of shape ``(4,)``.
     """
 
-    def f(x: np.ndarray):
+    def f(t: float, x: np.ndarray):
         theta1, theta2, omega1, omega2 = x
         delta = theta1 - theta2
 
@@ -63,14 +46,7 @@ def double_pendulum(
 
         return np.array([dtheta1_dt, dtheta2_dt, domega1_dt, domega2_dt])
 
-    t = np.arange(0, t_max, dt)
-    X = np.zeros((len(t), 4))
-    X[0] = X0
-
-    for i in range(1, len(t)):
-        X[i] = X[i - 1] + dt * f(X[i - 1])
-
-    return t, X
+    return f
 
 
 def to_xy(L1: float, L2: float, theta1: np.ndarray, theta2: np.ndarray):

edmkit-0.0.14/src/edmkit/generate/duffing.py

@@ -0,0 +1,31 @@
+import numpy as np
+
+__all__ = ["duffing"]
+
+
+def duffing(alpha: float, beta: float, delta: float, gamma: float, omega: float):
+    """Vector field of the forced Duffing oscillator.
+
+    Parameters
+    ----------
+    alpha : float
+        Linear stiffness (typical: -1).
+    beta : float
+        Cubic stiffness (typical: 1).
+    delta : float
+        Damping coefficient (typical: 0.3).
+    gamma : float
+        Forcing amplitude (typical: 0.5 for chaos).
+    omega : float
+        Forcing angular frequency (typical: 1.2).
+
+    Returns
+    -------
+    f : Callable[[float, np.ndarray], np.ndarray]
+        Right-hand side ``f(t, x)`` for a state ``(x, v)`` of shape ``(2,)``.
+    """
+
+    def f(t: float, x: np.ndarray):
+        return np.array([[0, 1], [-alpha - beta * x[0] ** 2, -delta]]) @ x + np.array([0, gamma * np.cos(omega * t)])
+
+    return f

edmkit-0.0.14/src/edmkit/generate/lorenz.py

@@ -0,0 +1,27 @@
+import numpy as np
+
+__all__ = ["lorenz"]
+
+
+def lorenz(sigma: float, rho: float, beta: float):
+    """Vector field of the Lorenz system.
+
+    Parameters
+    ----------
+    sigma : float
+        Prandtl number (typical: 10).
+    rho : float
+        Rayleigh number (typical: 28).
+    beta : float
+        Geometric factor (typical: 8/3).
+
+    Returns
+    -------
+    f : Callable[[float, np.ndarray], np.ndarray]
+        Right-hand side ``f(t, x)`` for a state ``(x, y, z)`` of shape ``(3,)``.
+    """
+
+    def f(t: float, x: np.ndarray):
+        return np.array([[-sigma, sigma, 0], [rho, -1, -x[0]], [0, x[0], -beta]]) @ x
+
+    return f

edmkit-0.0.14/src/edmkit/generate/lorenz96.py

@@ -0,0 +1,25 @@
+import numpy as np
+
+__all__ = ["lorenz96"]
+
+
+def lorenz96(F: float):
+    """Vector field of the Lorenz 96 system.
+
+    Parameters
+    ----------
+    F : float
+        Forcing constant (typical: 8 for chaos).
+
+    Returns
+    -------
+    f : Callable[[float, np.ndarray], np.ndarray]
+        Right-hand side ``f(t, x)`` for a state of shape ``(D,)`` with ``D >= 4``.
+    """
+
+    def f(t: float, x: np.ndarray):
+        # p[i + 2] is x[i] on the ring, so this is (x[i + 1] - x[i - 2]) * x[i - 1] - x[i] + F
+        p = np.concatenate([x[-2:], x, x[:1]])
+        return (p[3:] - p[:-3]) * p[1:-2] - x + F
+
+    return f

edmkit-0.0.14/src/edmkit/generate/rk45.py

@@ -0,0 +1,85 @@
+from collections.abc import Callable
+
+import numpy as np
+
+__all__ = ["rk45"]
+
+# Dormand-Prince 5(4)
+A = np.array(
+    [
+        [0, 0, 0, 0, 0, 0],
+        [1 / 5, 0, 0, 0, 0, 0],
+        [3 / 40, 9 / 40, 0, 0, 0, 0],
+        [44 / 45, -56 / 15, 32 / 9, 0, 0, 0],
+        [19372 / 6561, -25360 / 2187, 64448 / 6561, -212 / 729, 0, 0],
+        [9017 / 3168, -355 / 33, 46732 / 5247, 49 / 176, -5103 / 18656, 0],
+        [35 / 384, 0, 500 / 1113, 125 / 192, -2187 / 6784, 11 / 84],
+    ]
+)
+C = A.sum(axis=1)
+E = np.array([71 / 57600, 0, -71 / 16695, 71 / 1920, -17253 / 339200, 22 / 525, -1 / 40])
+
+
+def rk45(
+    f: Callable[[float, np.ndarray], np.ndarray],
+    X0: np.ndarray,
+    dt: float,
+    t_max: int,
+    rtol: float = 1e-6,
+    atol: float = 1e-9,
+):
+    """Integrate ``dx/dt = f(t, x)`` via the adaptive Dormand-Prince RK45 method.
+
+    The step size adapts between samples, while the output stays on the uniform grid of spacing ``dt``.
+
+    Parameters
+    ----------
+    f : Callable[[float, np.ndarray], np.ndarray]
+        Right-hand side of the system.
+    X0 : np.ndarray
+        Initial condition of shape ``(D,)``.
+    dt : float
+        Sampling time step.
+    t_max : int
+        Maximum time.
+    rtol : float
+        Relative tolerance of the local error.
+    atol : float
+        Absolute tolerance of the local error.
+
+    Returns
+    -------
+    t : np.ndarray
+        Time array.
+    X : np.ndarray
+        Trajectory of shape ``(N, D)``.
+    """
+    t = np.arange(0, t_max, dt)
+    X = np.zeros((len(t), len(X0)))
+    X[0] = X0
+
+    K = np.zeros((7, len(X0)))
+    h = dt
+
+    for i in range(1, len(t)):
+        s, x = t[i - 1], X[i - 1]
+
+        while s < t[i]:
+            last = h >= t[i] - s
+            step = t[i] - s if last else h
+
+            for j in range(7):
+                K[j] = f(s + C[j] * step, x + step * (A[j, :j] @ K[:j]))
+
+            x_new = x + step * (A[6] @ K[:6])
+            error = np.max(np.abs(step * (E @ K)) / (atol + rtol * np.maximum(np.abs(x), np.abs(x_new))))
+            accepted = error <= 1
+
+            if accepted:
+                s, x = t[i] if last else s + step, x_new
+            if not (accepted and last):
+                h = step * min(10, max(0.2, 0.9 * error**-0.2)) if error > 0 else step * 10
+
+        X[i] = x
+
+    return t, X

edmkit-0.0.14/src/edmkit/generate/rossler.py

@@ -0,0 +1,27 @@
+import numpy as np
+
+__all__ = ["rossler"]
+
+
+def rossler(a: float, b: float, c: float):
+    """Vector field of the Rössler system.
+
+    Parameters
+    ----------
+    a : float
+        Spiral growth rate (typical: 0.2).
+    b : float
+        Constant injection into z (typical: 0.2).
+    c : float
+        Folding threshold (typical: 5.7).
+
+    Returns
+    -------
+    f : Callable[[float, np.ndarray], np.ndarray]
+        Right-hand side ``f(t, x)`` for a state ``(x, y, z)`` of shape ``(3,)``.
+    """
+
+    def f(t: float, x: np.ndarray):
+        return np.array([[0, -1, -1], [1, a, 0], [0, 0, x[0] - c]]) @ x + np.array([0, 0, b])
+
+    return f

edmkit-0.0.13/src/edmkit/generate/__init__.py

@@ -1,5 +0,0 @@
-from .double_pendulum import double_pendulum, to_xy
-from .lorenz import lorenz
-from .mackey_glass import mackey_glass
-
-__all__ = ["double_pendulum", "lorenz", "mackey_glass", "to_xy"]

edmkit-0.0.13/src/edmkit/generate/lorenz.py

@@ -1,49 +0,0 @@
-import numpy as np
-
-__all__ = ["lorenz"]
-
-
-def lorenz(
-    sigma: float,
-    rho: float,
-    beta: float,
-    X0: np.ndarray,
-    dt: float,
-    t_max: int,
-):
-    """Generate a Lorenz system trajectory via forward Euler integration.
-
-    Parameters
-    ----------
-    sigma : float
-        Prandtl number (typical: 10).
-    rho : float
-        Rayleigh number (typical: 28).
-    beta : float
-        Geometric factor (typical: 8/3).
-    X0 : np.ndarray
-        Initial condition of shape ``(3,)``.
-    dt : float
-        Integration time step.
-    t_max : int
-        Maximum time.
-
-    Returns
-    -------
-    t : np.ndarray
-        Time array.
-    X : np.ndarray
-        Trajectory of shape ``(N, 3)`` for ``(x, y, z)``.
-    """
-
-    def f(x: np.ndarray):
-        return np.array([[-sigma, sigma, 0], [rho, -1, -x[0]], [0, x[0], -beta]]) @ x
-
-    t = np.arange(0, t_max, dt)
-    X = np.zeros((len(t), 3))
-    X[0] = X0
-
-    for i in range(1, len(t)):
-        X[i] = X[i - 1] + dt * f(X[i - 1])
-
-    return t, X