edmkit 0.0.0__tar.gz

edmkit-0.0.0/.claude/settings.json

@@ -0,0 +1,13 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(grep:*)",
+      "Bash(uv run ruff:*)",
+      "Bash(uv run ty:*)",
+      "Bash(uv run pytest:*)",
+      "Bash(uv run python:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

edmkit-0.0.0/.github/workflows/ci.yaml

@@ -0,0 +1,40 @@
+# Basic CI setup: Lint with ruff, run tests with pytest
+name: Test
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+jobs:
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v3
+      - name: Ruff lint
+        run: uv run ruff check .
+      - name: Ruff format
+        run: uv run ruff format --diff .
+
+  type-check:
+    name: Type check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v3
+      - name: Ty type check
+        run: uv run ty check
+
+  test:
+    name: Run tests
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v3
+      - run: uv run pytest

edmkit-0.0.0/.github/workflows/release.yaml

@@ -0,0 +1,29 @@
+name: Release
+
+on:
+  push:
+
+jobs:
+  pypi:
+    name: Publish to PyPI
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+      - name: Install Python 3.13
+        run: uv python install 3.13
+      - name: Build
+        run: uv build
+      - name: Smoke test (wheel)
+        run: uv run --isolated --no-project --with dist/*.whl tests/smoke_test.py
+      - name: Smoke test (source distribution)
+        run: uv run --isolated --no-project --with dist/*.tar.gz tests/smoke_test.py
+      - name: Publish
+        run: uv publish

edmkit-0.0.0/.gitignore

@@ -0,0 +1,10 @@
+# python generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# venv
+.venv

edmkit-0.0.0/.python-version

@@ -0,0 +1 @@
+3.13.0

edmkit-0.0.0/CLAUDE.md

@@ -0,0 +1,75 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+edmkit is a Python library for Empirical Dynamic Modeling (EDM), providing tools for nonlinear time series analysis including embedding, simplex projection, S-Map, and convergent cross mapping.
+
+## Development Commands
+
+### Testing
+```bash
+# Run all tests
+uv run pytest tests/
+
+# Run a specific test file
+uv run pytest tests/test_simplex_projection.py
+
+# Run tests with verbose output
+uv run pytest -v tests/
+```
+
+### Type Checking
+```bash
+# Type check
+uv run ty check .
+```
+
+### Linting and Formatting
+```bash
+# Check code style and linting issues
+uv run ruff check .
+
+# Auto-format code
+uv run ruff format .
+
+# Check specific file
+uv run ruff check src/edmkit/simplex_projection.py
+```
+
+### Installation and Dependencies
+```bash
+# Install in development mode with uv (recommended)
+uv sync --dev
+
+# Do not use pip interface
+```
+
+## Architecture and Code Structure
+
+### Core Modules
+- **embedding.py**: Time series embedding using lagged coordinates. Key function: `embed()`
+- **simplex_projection.py**: Nearest-neighbor forecasting in phase space. Key function: `simplex_projection()`
+- **smap.py**: Sequential Locally Weighted Global Linear Maps. Key function: `smap()`
+- **ccm.py**: Convergent Cross Mapping for causality detection.
+- **tensor.py**: Abstraction layer over tinygrad for GPU acceleration
+- **util.py**: Utility functions including distance calculations, autocorrelation, DTW
+
+### Key Design Patterns
+1. **Functional API**: Most functions are pure with NumPy array inputs/outputs
+2. **GPU Acceleration**: Uses tinygrad tensors internally for performance
+3. **Input Validation**: Extensive assertions with informative error messages
+4. **Vectorized Operations**: Leverages NumPy/tinygrad broadcasting for efficiency
+5. **Minimal Dependency**: Use minimal dependencies and all of usage should be justified
+
+### Testing Approach
+- Tests compare outputs against pyEDM reference implementation
+- Use synthetic data from generators (Lorenz, Mackey-Glass, etc.) as fixture
+- Test files mirror source structure (e.g., `test_simplex_projection.py` for `simplex_projection.py`)
+
+### Important Implementation Details
+1. **Distance Calculations**: The library uses custom distance functions that handle NaN values specially
+2. **Platform Considerations**: Special handling for macOS non-ARM systems regarding Metal backend
+3. **API Stability**: The library is under active development - expect API changes
+4. **Tensor Conversion**: Functions convert between NumPy arrays and tinygrad tensors internally

edmkit-0.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 temma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

edmkit-0.0.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: edmkit
+Version: 0.0.0
+Summary: Simple EDM (Empirical Dynamic Modeling) library
+Author-email: FUJISHIGE TEMMA <tenma.x0@gmail.com>
+License-File: LICENSE
+Requires-Python: >=3.13
+Requires-Dist: numpy>=2.3.4
+Requires-Dist: tinygrad>=0.11.0
+Description-Content-Type: text/markdown
+
+# edmkit
+
+This library is a collection of tools and utilities that are useful for Empirical Data Modeling (EDM) and related tasks. The library is designed to be fast and lightweight, and easy to use.
+
+::: warning
+This library is still under intensive development so API may change in the future.
+:::
+
+## Installation
+
+To install the library, you can use pip:
+
+```bash
+pip install edmkit
+```
+
+Or you can also use [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv add edmkit
+```
+
+## Usage
+
+Most of the functions accept and return `numpy` arrays or `edmkit.Tensor`(alias to `tinygrad.Tensor`).

edmkit-0.0.0/README.md

@@ -0,0 +1,25 @@
+# edmkit
+
+This library is a collection of tools and utilities that are useful for Empirical Data Modeling (EDM) and related tasks. The library is designed to be fast and lightweight, and easy to use.
+
+::: warning
+This library is still under intensive development so API may change in the future.
+:::
+
+## Installation
+
+To install the library, you can use pip:
+
+```bash
+pip install edmkit
+```
+
+Or you can also use [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv add edmkit
+```
+
+## Usage
+
+Most of the functions accept and return `numpy` arrays or `edmkit.Tensor`(alias to `tinygrad.Tensor`).

edmkit-0.0.0/debug.py

@@ -0,0 +1,235 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import pyEDM
+
+from edmkit import generate, tensor
+from edmkit.embedding import lagged_embed
+from edmkit.simplex_projection import simplex_projection
+from edmkit.util import pairwise_distance, topk
+
+
+def logistic_map(n: int = 200):
+    """Generate logistic map time series x."""
+    x = np.zeros(n)
+    x[0] = 0.1
+    # Logistic map
+    for i in range(1, n):
+        x[i] = 3.8 * x[i - 1] * (1 - x[i - 1])
+    return x
+
+
+def lorenz(n: int = 200):
+    """Generate Lorenz attractor time series x."""
+    sigma, rho, beta = 10, 28, 8 / 3
+    X0 = np.array([1.0, 1.0, 1.0])
+    t_max = 30
+    dt = t_max / (n * 10)  # Generate enough points before subsampling
+
+    t, X = generate.lorenz(sigma, rho, beta, X0, dt, t_max)
+    return X[::10, 0][:n]  # Ensure we get exactly n points
+
+
+def mackey_glass(n: int = 200):
+    """Generate Mackey-Glass time series x."""
+    tau, n_exponent = 17, 10
+    beta, gamma = 0.2, 0.1
+    x0 = 0.9
+    t_max = 200
+    dt = t_max / n
+
+    t, x = generate.mackey_glass(tau, n_exponent, beta, gamma, x0, dt, t_max)
+    return x
+
+
+params = [
+    ("logistic_map", 3, 2),
+    ("lorenz", 3, 1),
+    ("mackey_glass", 4, 2),
+]
+
+
+def main():
+    for data, E, tau in params:
+        if data == "logistic_map":
+            x = logistic_map()
+        elif data == "lorenz":
+            x = lorenz()
+        elif data == "mackey_glass":
+            x = mackey_glass()
+        else:
+            raise ValueError(f"Unknown data type: {data}")
+
+        # common parameters
+        lib_size = 150
+        Tp = 2
+
+        # pyEDM
+        df = pd.DataFrame({"time": np.arange(len(x)), "value": x})
+        lib, pred = f"1 {lib_size}", f"{lib_size + 1} {len(x)}"
+        pyedm_result = pyEDM.Simplex(dataFrame=df, lib=lib, pred=pred, E=E, tau=-tau, columns="value", target="value", Tp=Tp, verbose=False)
+        pyedm_predictions = pyedm_result["Predictions"].values[Tp:-Tp]  # first Tp values are NaN, last Tp values are not in true x
+
+        # edmkit
+        embedding = lagged_embed(x, tau, E)
+        shift = tau * (E - 1)  # embedding starts at this index (i.e. embedding[0][0] == x[shift])
+        X = embedding[: lib_size - shift]
+        Y = embedding[Tp : lib_size - shift + Tp, 0]  # shifted by Tp
+
+        query_points = embedding[lib_size - shift :]
+        edmkit_predictions = simplex_projection(X, Y, query_points)[:-Tp]  # last Tp values are not in true x
+
+        ground_truth = x[lib_size + Tp :]
+        pyedm_rmse = np.sqrt(np.mean((pyedm_predictions - ground_truth) ** 2))
+        edmkit_rmse = np.sqrt(np.mean((edmkit_predictions - ground_truth) ** 2))
+
+        diff = edmkit_predictions - pyedm_predictions
+
+        fig1 = plt.figure(figsize=(10, 6))
+
+        ax1 = fig1.add_subplot(2, 1, 1)
+
+        ax1.plot(ground_truth, label="Ground Truth", color="black")
+        ax1.plot(pyedm_predictions, label="pyEDM Predictions", linestyle="--", color="blue")
+        ax1.plot(edmkit_predictions, label="edmkit Predictions", linestyle=":", color="red")
+
+        print(pyedm_predictions.shape, edmkit_predictions.shape, ground_truth.shape, X.shape, Y.shape, query_points.shape)
+
+        large_diff = np.abs(diff) > np.max(np.abs(diff)) * 0.1
+        ax1.vlines(
+            np.where(large_diff)[0], ymin=0, ymax=1, color="orange", alpha=0.3, label="Significant Difference", transform=ax1.get_xaxis_transform()
+        )
+
+        ax2 = fig1.add_subplot(2, 1, 2, sharex=ax1)
+        ax2.plot(diff, label="Difference (edmkit - pyEDM)", color="green")
+        ax2.vlines(
+            np.where(large_diff)[0], ymin=0, ymax=1, color="orange", alpha=0.3, label="Significant Difference", transform=ax2.get_xaxis_transform()
+        )
+        ax2.axhline(0, color="black", linestyle="--")
+
+        fig1.tight_layout()
+        fig1.legend()
+        plt.show()
+
+        # display embedding in 3D
+        fig2 = plt.figure(figsize=(10, 6))
+        ax3 = fig2.add_subplot(111, projection="3d")
+
+        ax3.set_title(f"Embedding (E={E}, tau={tau})")
+
+        ax3.scatter(X[:, 0], X[:, 1], X[:, 2], c=np.arange(len(X)), cmap="viridis", s=3)  # type: ignore
+        ax3.set_xlabel("X(t)")
+        ax3.set_ylabel(f"X(t-{tau})")
+        ax3.set_zlabel(f"X(t-{2 * tau})")  # type: ignore
+
+        ax3.scatter(
+            query_points[:-Tp, 0],
+            query_points[:-Tp, 1],
+            query_points[:-Tp, 2],
+            c="black",
+            s=5,  # type: ignore
+            label="Query Points",
+        )
+        ax3.scatter(
+            query_points[:-Tp, 0][large_diff],
+            query_points[:-Tp, 1][large_diff],
+            query_points[:-Tp, 2][large_diff],
+            c="red",
+            s=5,  # type: ignore
+            label="Significant Difference",
+        )
+        ax3.scatter(
+            pyedm_predictions[large_diff],
+            pyedm_predictions[large_diff],
+            pyedm_predictions[large_diff],
+            c="blue",
+            s=5,  # type: ignore
+            label="pyEDM Predictions",
+            marker="x",
+        )
+        ax3.scatter(
+            edmkit_predictions[large_diff],
+            edmkit_predictions[large_diff],
+            edmkit_predictions[large_diff],
+            c="red",
+            s=5,  # type: ignore
+            label="edmkit Predictions",
+            marker="x",
+        )
+
+        fig2.tight_layout()
+        fig2.legend()
+        plt.show()
+
+        fig3 = plt.figure(figsize=(10, 6))
+        ax4 = fig3.add_subplot(111, projection="3d")
+        ax4.set_title("Sample #1 with Significant Difference (with neighbors)")
+
+        pyedm_result_object = pyEDM.Simplex(
+            dataFrame=df, lib=lib, pred=pred, E=E, tau=-tau, columns="value", target="value", Tp=Tp, verbose=False, returnObject=True
+        )
+        print(pyedm_result_object.libOverlap)
+
+        query_point = query_points[:-Tp][large_diff][0]
+
+        pyedm_neighbor_indices = pyedm_result_object.knn_neighbors[:-Tp][large_diff][0]
+
+        D = pairwise_distance(tensor.Tensor(query_points, dtype=tensor.dtypes.float32), tensor.Tensor(X, dtype=tensor.dtypes.float32)).numpy()
+        D = np.sqrt(D)
+
+        k: int = X.shape[1] + 1
+        neighbor_indices = np.zeros((len(query_points), k))
+
+        for i in range(len(query_points)):
+            # find k nearest neighbors
+            indices, distances = topk(D[i], k, largest=False)
+            neighbor_indices[i] = indices
+
+        edmkit_neighbor_index = neighbor_indices[:-Tp][large_diff][0].astype(int)
+
+        pyedm_neighbors = X[pyedm_neighbor_indices]
+        edmkit_neighbors = X[edmkit_neighbor_index]
+
+        ax4.scatter(X[:, 0], X[:, 1], X[:, 2], c=np.arange(len(X)), cmap="viridis", s=3, zorder=1)  # type: ignore
+        ax4.scatter(
+            query_point[0],
+            query_point[1],
+            query_point[2],
+            c="black",
+            s=10,  # type: ignore
+            label="Query Point",
+            zorder=2,
+        )
+        ax4.scatter(
+            edmkit_neighbors[:, 0],
+            edmkit_neighbors[:, 1],
+            edmkit_neighbors[:, 2],
+            c="red",
+            s=10,  # type: ignore
+            label="edmkit Neighbors",
+            marker="x",
+            zorder=3,
+        )
+        ax4.scatter(
+            pyedm_neighbors[:, 0],
+            pyedm_neighbors[:, 1],
+            pyedm_neighbors[:, 2],
+            c="blue",
+            s=10,  # type: ignore
+            label="pyEDM Neighbors",
+            marker="x",
+            zorder=4,
+        )
+
+        fig3.tight_layout()
+        fig3.legend()
+        plt.show()
+
+        try:
+            assert np.abs(pyedm_rmse - edmkit_rmse) < 1e-6, f"RMSE: pyEDM {pyedm_rmse}, edmkit {edmkit_rmse}, diff {np.abs(pyedm_rmse - edmkit_rmse)}"
+        except AssertionError as e:
+            print(f"AssertionError: {e}")
+
+
+if __name__ == "__main__":
+    main()

edmkit-0.0.0/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "edmkit"
+version = "0.0.0"
+description = "Simple EDM (Empirical Dynamic Modeling) library"
+authors = [{ name = "FUJISHIGE TEMMA", email = "tenma.x0@gmail.com" }]
+readme = "README.md"
+requires-python = ">= 3.13"
+dependencies = ["numpy>=2.3.4", "tinygrad>=0.11.0"]
+
+[dependency-groups]
+dev = ["pyedm>=2.2.4", "pytest>=8.4.2", "ruff>=0.14.0", "ty>=0.0.1a22"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

edmkit-0.0.0/ruff.toml

@@ -0,0 +1 @@
+line-length = 150

edmkit-0.0.0/src/edmkit/__init__.py

@@ -0,0 +1,4 @@
+# ruff: noqa: F401
+from .embedding import lagged_embed
+from .simplex_projection import simplex_projection
+from .smap import smap

edmkit-0.0.0/src/edmkit/ccm.py

@@ -0,0 +1,76 @@
+import numpy as np
+
+from edmkit.embedding import lagged_embed
+from edmkit.tensor import Tensor, dtypes
+from edmkit.util import pad, pairwise_distance, topk
+
+
+def calculate_rho(observations: np.ndarray, predictions: np.ndarray):
+    assert len(observations) == len(predictions), "observations and predictions must have the same length"
+    return np.corrcoef(observations.T, predictions.T)[0, 1]
+
+
+def search_best_embedding(
+    x: np.ndarray, tau_list: list[int], e_list: list[int], Tp: int, max_L: int | None = None, rng: np.random.Generator | None = None
+):
+    assert all(tau > 0 for tau in tau_list), f"tau must be positive, got tau_list={tau_list}"
+    assert all(e > 0 for e in e_list), f"e must be positive, got e_list={e_list}"
+    assert max_L is None or max_L <= len(x), f"max_L must be less than or equal to len(x), got max_L={max_L} and len(x)={len(x)}"
+
+    if rng is None:
+        rng = np.random.default_rng()
+
+    if max_L is not None:
+        x = x[rng.choice(len(x), min(len(x), max_L), replace=False)]
+
+    # lagged_embed(x, tau, e).shape[0] == len(x) - (e - 1) * tau
+    min_L = len(x) - (max(e_list) - 1) * max(tau_list)
+    assert min_L > 0, (
+        f"Not enough data points to embed, got len(x)(={len(x)}) - max(e)(={max(e_list)}) * max(tau)(={max(tau_list)}) = min_L(={min_L})"
+    )
+
+    embeddings: list[np.ndarray] = []
+    for tau in tau_list:
+        for e in e_list:
+            # align the time indices of the embeddings. note that the time index of the first embedding is `1 + (e - 1) * tau`
+            embeddings.append(lagged_embed(x, tau, e)[-min_L:])  # (min_L, e)
+
+    X = pad(embeddings)  # X.shape == (len(tau_list) * len(e_list), min_L, max(e_list))
+    D = pairwise_distance(Tensor(X, dtype=dtypes.float32)).numpy()
+
+    L = min_L
+    seq = np.arange(L)
+    lib_size = L // 2
+
+    rho = np.zeros((len(tau_list), len(e_list)))
+
+    for i, tau in enumerate(tau_list):
+        for j, e in enumerate(e_list):
+            batch = i * len(e_list) + j
+
+            samples_indecies = np.arange(lib_size, L)
+
+            observations = X[batch, samples_indecies, :e]
+            predictions = np.zeros((len(samples_indecies), e), dtype=x.dtype)
+
+            for k, t in enumerate(samples_indecies):
+                # [0, 1, 2, 3, 4 | 5, 6, 7, 8, 9, 10]; initialize mask, `|` separates lib and test
+                mask = np.ones(L, dtype=bool)
+
+                # [0, 1, 2, 3, 4 | 5, F, 7, 8, 9, 10], t = 6; exclude self
+                mask[t] = False
+
+                # [0, 1, 2, 3, 4 | 5, F, 7, 8, F, F ], Tp = 2; exclude last Tp points to prevent out-of-bound indexing on predictions
+                mask[-Tp:] = False
+
+                # [0, 1, 2, 3, 4 | F, F, F, F, F, F ], lib_size = 5; exclude test points
+                mask[lib_size:] = False
+
+                # find k(=e+1) nearest neighbors in phase space for simplex projection
+                indices_masked, _ = topk(D[batch, t, mask], e + 1, largest=False)
+                indices = seq[mask][indices_masked]
+                predictions[k] = X[batch, indices + Tp, :e].mean()
+
+            rho[i, j] = calculate_rho(observations, predictions)
+
+    return rho

edmkit-0.0.0/src/edmkit/embedding.py

@@ -0,0 +1,56 @@
+import numpy as np
+
+
+def lagged_embed(x: np.ndarray, tau: int, e: int):
+    """Lagged embedding of a time series `x`.
+
+    Parameters
+    ----------
+        `x` : `np.ndarray` of shape `(N,)`
+        `tau` : `int`
+        `e` : `int`
+
+    Returns
+    -------
+        `np.ndarray` of shape `(N - (e - 1) * tau, e)`
+
+    Raises
+    ------
+    AssertionError
+        - If `x` is not a 1D array.
+        - If `tau` or `e` is not positive.
+        - If `e * tau >= len(x)`.
+
+    Notes
+    -----
+    - While open to interpretation, it's generally more intuitive to consider the embedding as starting from the `(e - 1) * tau`th element of the original time series and ending at the `len(x) - 1`th element (the last value), rather than starting from the 0th element and ending at `len(x) - 1 - (e - 1) * tau`.
+    - This distinction reflects whether we think of "attaching past values to the present" or "attaching future values to the present". The information content of the result is the same either way.
+    - The use of `reversed` in the implementation emphasizes this perspective.
+
+    Examples
+    --------
+    ```
+    import numpy as np
+    from edm.embedding import lagged_embed
+
+    x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+    tau = 2
+    e = 3
+
+    E = lagged_embed(x, tau, e)
+    print(E)
+    print(E.shape)
+    # [[4 2 0]
+    #  [5 3 1]
+    #  [6 4 2]
+    #  [7 5 3]
+    #  [8 6 4]
+    #  [9 7 5]]
+    # (6, 3)
+    ```
+    """
+    assert len(x.shape) == 1, f"X must be a 1D array, got x.shape={x.shape}"
+    assert tau > 0 and e > 0, f"tau and e must be positive, got tau={tau}, e={e}"
+    assert (e - 1) * tau <= x.shape[0], f"e and tau must satisfy `(e - 1) * tau < len(X)`, got e={e}, tau={tau}"
+
+    return np.array([x[tau * (e - 1) :]] + [x[tau * i : -tau * ((e - 1) - i)] for i in reversed(range(e - 1))]).transpose()

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

@@ -0,0 +1,4 @@
+# ruff: noqa: F401
+from .double_pendulum import double_pendulum, to_xy
+from .lorenz import lorenz
+from .mackey_glass import mackey_glass