yennefer 0.2.0__tar.gz

yennefer-0.2.0/LICENSE

@@ -0,0 +1,98 @@
+The YEN library
+Copyright (c) 2026 Gregory Shipunov (aka. GrindelfP)
+
+This project is licensed under the MIT License - see below for the full text.
+The project also includes third-party software components licensed under different terms.
+
+==============================================================================
+PART 1: MIT License (Everything except DOP853 Implementation)
+==============================================================================
+Copyright (c) 2026 Gregory Shipunov (aka. GrindelfP)
+
+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.
+
+==============================================================================
+PART 2: Third-Party Licenses (DOP853 Implementation)
+==============================================================================
+The DOP853 implementation in this library is a derivative work based on
+the following sources. These components are subject to the terms and
+conditions of their respective licenses:
+
+------------------------------------------------------------------------------
+Source: Modern Fortran Edition of the DOP853
+Author: Jacob Williams (https://github.com/jacobwilliams/dop853)
+License: BSD 3-Clause
+------------------------------------------------------------------------------
+Copyright (c) 2015-2022, Jacob Williams
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+
+* The names of its contributors may not be used to endorse or promote products
+  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+------------------------------------------------------------------------------
+Source: Original DOP853
+Author: Ernst Hairer (http://www.unige.ch/~hairer/prog/nonstiff/dop853.f)
+License: Hairer License (BSD-style)
+------------------------------------------------------------------------------
+
+Copyright (c) 2004, Ernst Hairer
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+- Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS �AS
+IS� AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

yennefer-0.2.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: yennefer
+Version: 0.2.0
+Summary: Fast numerical ODE solvers (RK4, RK45, DOP853) optimized with Numba.
+Author-email: "Gregory Shipunov (aka GrindelfP.)" <grindelf.perlomutrovij@gmail.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: numba
+Dynamic: license-file
+
+# YENNEFER ODE SOLVER 
+
+## Description
+
+This is an ordinary differential equations systems solver library named Yen (after Yennefer of Vengerberg). Fast numerical ODE solvers (RK4, RK45, DOP853) optimized with Numba.

yennefer-0.2.0/README.md

@@ -0,0 +1,5 @@
+# YENNEFER ODE SOLVER 
+
+## Description
+
+This is an ordinary differential equations systems solver library named Yen (after Yennefer of Vengerberg). Fast numerical ODE solvers (RK4, RK45, DOP853) optimized with Numba.

yennefer-0.2.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "yennefer"
+version = "0.2.0"
+description = "Fast numerical ODE solvers (RK4, RK45, DOP853) optimized with Numba."
+readme = "README.md"
+authors = [
+    { name = "Gregory Shipunov (aka GrindelfP.)", email = "grindelf.perlomutrovij@gmail.com" }
+]
+requires-python = ">=3.10"
+dependencies = [
+    "numpy",
+    "numba"
+]
+
+[tool.setuptools.packages.find]
+include = ["yen*"]

yennefer-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

yennefer-0.2.0/yennefer/__init__.py

@@ -0,0 +1,13 @@
+"""
+yennefer - Numerical integration library for Ordinary Differential Equations.
+"""
+
+from .rk4 import RK4Solver
+from .rk45 import RK45Solver
+from .dop853 import DOP853Solver
+
+__all__ = [
+    "RK4Solver",
+    "RK45Solver",
+    "DOP853Solver",
+]

yennefer-0.2.0/yennefer/dop853.py

@@ -0,0 +1,243 @@
+"""
+DOP853 — Dormand-Prince 8(5,3) explicit Runge-Kutta method.
+
+Source: Hairer E., Nørsett S.P., Wanner G.
+        "Solving Ordinary Differential Equations I", 2nd ed., Springer, 1993.
+
+Based on the DOP853 implementation by Ernst Hairer and Jacob Williams.
+Original Fortran source: https://github.com/jacobwilliams/dop853
+See LICENSE file for full license text.
+"""
+
+from __future__ import annotations
+
+from typing import Callable
+
+import numpy as np
+from numpy.typing import NDArray
+from numba import njit
+
+from .dop853_constants import *
+
+F = Callable[[float, NDArray[np.float64], NDArray[np.float64]], NDArray[np.float64]]
+
+@njit
+def _dop853_integrate(
+        f: F,
+        y0: NDArray[np.float64],
+        dt_init: float,
+        t_max: float,
+        params: NDArray[np.float64],
+        rtol: float,
+        atol: float,
+        n_max_steps: int,
+        fac1: float = 0.333,
+        fac2: float = 6.0,
+        safe: float = 0.9,
+        beta: float = 0.0,
+) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+    n_vars = y0.shape[0]
+
+    # Pre-allocate arrays
+    t_arr = np.empty(n_max_steps + 1, dtype=np.float64)
+    y_arr = np.empty((n_max_steps + 1, n_vars), dtype=np.float64)
+
+    t = 0.0
+    y = np.copy(y0)
+
+    t_arr[0] = t
+    y_arr[0] = y
+
+    h = dt_init
+    idx = 1
+    nstep = 0
+
+    k1 = f(t, y, params)
+
+    facold = 1.0e-4
+    expo1 = 1.0 / 8.0 - beta * 0.2
+    facc1 = 1.0 / fac1
+    facc2 = 1.0 / fac2
+
+    posneg = 1.0 if t_max > 0.0 else -1.0
+    reject = False
+    last = False
+
+    while t < t_max and nstep < n_max_steps:
+
+        if np.abs(h) < np.abs(t) * np.finfo(np.float64).eps:
+            # Step size too small
+            break
+
+        if (t + 1.01 * h - t_max) * posneg > 0.0:
+            h = t_max - t
+            last = True
+
+        nstep += 1
+
+        # --- 12 Stages computation ---
+        y_tmp = y + h * A21 * k1
+        k2 = f(t + C2 * h, y_tmp, params)
+
+        y_tmp = y + h * (A31 * k1 + A32 * k2)
+        k3 = f(t + C3 * h, y_tmp, params)
+
+        y_tmp = y + h * (A41 * k1 + A43 * k3)
+        k4 = f(t + C4 * h, y_tmp, params)
+
+        y_tmp = y + h * (A51 * k1 + A53 * k3 + A54 * k4)
+        k5 = f(t + C5 * h, y_tmp, params)
+
+        y_tmp = y + h * (A61 * k1 + A64 * k4 + A65 * k5)
+        k6 = f(t + C6 * h, y_tmp, params)
+
+        y_tmp = y + h * (A71 * k1 + A74 * k4 + A75 * k5 + A76 * k6)
+        k7 = f(t + C7 * h, y_tmp, params)
+
+        y_tmp = y + h * (A81 * k1 + A84 * k4 + A85 * k5 + A86 * k6 + A87 * k7)
+        k8 = f(t + C8 * h, y_tmp, params)
+
+        y_tmp = y + h * (A91 * k1 + A94 * k4 + A95 * k5 + A96 * k6 + A97 * k7 + A98 * k8)
+        k9 = f(t + C9 * h, y_tmp, params)
+
+        y_tmp = y + h * (A101 * k1 + A104 * k4 + A105 * k5 + A106 * k6 + A107 * k7 + A108 * k8 + A109 * k9)
+        k10 = f(t + C10 * h, y_tmp, params)
+
+        y_tmp = y + h * (
+                    A111 * k1 + A114 * k4 + A115 * k5 + A116 * k6 + A117 * k7 + A118 * k8 + A119 * k9 + A1110 * k10)
+        k11 = f(t + C11 * h, y_tmp, params)
+
+        t_next = t + h
+        y_tmp = y + h * (
+                    A121 * k1 + A124 * k4 + A125 * k5 + A126 * k6 + A127 * k7 + A128 * k8 + A129 * k9 + A1210 * k10 + A1211 * k11)
+        k12 = f(t_next, y_tmp, params)
+
+        k_final = B1 * k1 + B6 * k6 + B7 * k7 + B8 * k8 + B9 * k9 + B10 * k10 + B11 * k11 + B12 * k12
+        y_next = y + h * k_final
+
+        # --- Error estimation ---
+        err = 0.0
+        err2 = 0.0
+
+        for i in range(n_vars):
+            sk = atol + rtol * max(abs(y[i]), abs(y_next[i]))
+            erri = k_final[i] - BHH1 * k1[i] - BHH2 * k9[i] - BHH3 * k12[i]
+            err2 += (erri / sk) ** 2
+
+            erri_2 = (ER1 * k1[i] + ER6 * k6[i] + ER7 * k7[i] + ER8 * k8[i] +
+                      ER9 * k9[i] + ER10 * k10[i] + ER11 * k11[i] + ER12 * k12[i])
+            err += (erri_2 / sk) ** 2
+
+        deno = err + 0.01 * err2
+        if deno <= 0.0:
+            deno = 1.0
+
+        err = abs(h) * err * np.sqrt(1.0 / (n_vars * deno))
+
+        # --- Computation of hnew ---
+        fac11 = err ** expo1
+        fac = fac11 / (facold ** beta)
+        fac = max(facc2, min(facc1, fac / safe))
+        h_new = h / fac
+
+        if err <= 1.0:
+            # Step is accepted
+            facold = max(err, 1.0e-4)
+            k_new_eval = f(t_next, y_next, params)  # New k1 mapping
+
+            k1 = k_new_eval
+            y = y_next
+            t = t_next
+
+            t_arr[idx] = t
+            y_arr[idx] = y
+            idx += 1
+
+            if last:
+                h = h_new
+                break
+
+            if reject:
+                h_new = posneg * min(abs(h_new), abs(h))
+
+            reject = False
+        else:
+            # Step is rejected
+            h_new = h / min(facc1, fac11 / safe)
+            reject = True
+            last = False
+
+        h = h_new
+
+    return t_arr[:idx], y_arr[:idx]
+
+
+class DOP853Solver:
+    """Adaptive-step Runge-Kutta 8th-order ODE solver (Dormand & Prince 8(5,3)).
+
+    The right-hand side ``f`` must have the signature::
+
+        f(t: float, y: NDArray[float64], params: NDArray[float64]) -> NDArray[float64]
+
+    The core method ``_dop853_integrate`` is decorated with ``@njit``
+    and is compiled on the first call. For maximum performance, decorate
+    ``f`` with ``@njit`` as well before passing it to the solver.
+    """
+
+    def __init__(
+            self,
+            function: F,
+            y0: NDArray[np.float64],
+            params: NDArray[np.float64],
+            rtol: float = 1e-9,
+            atol: float = 1e-9,
+            n_max_steps: int = np.inf,
+    ) -> None:
+        self._f = function
+        self._y0 = np.asarray(y0, dtype=np.float64)
+        self._params = np.asarray(params, dtype=np.float64)
+
+        self.rtol = rtol
+        self.atol = atol
+        self.n_max_steps = n_max_steps
+
+        self._t: NDArray[np.float64] | None = None
+        self._y: NDArray[np.float64] | None = None
+
+    def solve(self, t_max: float, dt_init: float) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+        """Run the integration from ``t = 0`` to ``t_max``.
+
+        ``dt`` serves as the initial step size guess (`h_init`) for the adaptive algorithm.
+
+        Returns
+        -------
+        t : NDArray[float64], shape (N_accepted_steps,)
+            Time grid at accepted adaptive steps.
+        y : NDArray[float64], shape (N_accepted_steps, n_vars)
+            Solution at each accepted time point.
+        """
+        self._t, self._y = _dop853_integrate(
+            self._f,
+            self._y0,
+            dt_init,
+            t_max,
+            self._params,
+            self.rtol,
+            self.atol,
+            self.n_max_steps
+        )
+        return self._t, self._y
+
+    @property
+    def t(self) -> NDArray[np.float64]:
+        """Time grid from the last ``solve()`` call."""
+        if self._t is None:
+            raise RuntimeError("Call solve() first.")
+        return self._t
+
+    @property
+    def y(self) -> NDArray[np.float64]:
+        """Solution array from the last ``solve()`` call."""
+        if self._y is None:
+            raise RuntimeError("Call solve() first.")
+        return self._y

yennefer-0.2.0/yennefer/dop853_constants.py

@@ -0,0 +1,107 @@
+"""
+DOP853 — Dormand-Prince 8(5,3) explicit Runge-Kutta method.
+
+Source: Hairer E., Nørsett S.P., Wanner G.
+        "Solving Ordinary Differential Equations I", 2nd ed., Springer, 1993.
+
+Based on the DOP853 implementation by Ernst Hairer and Jacob Williams.
+Original Fortran source: https://github.com/jacobwilliams/dop853
+See LICENSE file for full license text.
+"""
+
+# ==============================================================================
+# DOP853 Coefficients
+# ==============================================================================
+C2 = 0.0526001519587677318785587544488
+C3 = 0.0789002279381515978178381316732
+C4 = 0.118350341907227396726757197510
+C5 = 0.281649658092772603273242802490
+C6 = 0.333333333333333333333333333333
+C7 = 0.25
+C8 = 0.307692307692307692307692307692
+C9 = 0.651282051282051282051282051282
+C10 = 0.6
+C11 = 0.857142857142857142857142857142
+
+B1 = 0.0542937341165687622380535766363
+B6 = 4.45031289275240888144113950566
+B7 = 1.89151789931450038304281599044
+B8 = -5.8012039600105847814672114227
+B9 = 0.31116436695781989440891606237
+B10 = -0.152160949662516078556178806805
+B11 = 0.201365400804030348374776537501
+B12 = 0.0447106157277725905176885569043
+
+BHH1 = 0.244094488188976377952755905512
+BHH2 = 0.733846688281611857341361741547
+BHH3 = 0.0220588235294117647058823529412
+
+ER1 = 0.01312004499419488073250102996
+ER6 = -1.225156446376204440720569753
+ER7 = -0.4957589496572501915214079952
+ER8 = 1.664377182454986536961530415
+ER9 = -0.3503288487499736816886487290
+ER10 = 0.3341791187130174790297318841
+ER11 = 0.08192320648511571246570742613
+ER12 = -0.02235530786388629525884427845
+
+A21 = 0.0526001519587677318785587544488
+
+A31 = 0.0197250569845378994544595329183
+A32 = 0.0591751709536136983633785987549
+
+A41 = 0.0295875854768068491816892993775
+A43 = 0.0887627564304205475450678981324
+
+A51 = 0.241365134159266685502369798665
+A53 = -0.884549479328286085344864962717
+A54 = 0.924834003261792003115737966543
+
+A61 = 0.037037037037037037037037037037
+A64 = 0.170828608729473871279604482173
+A65 = 0.125467687566822425016691814123
+
+A71 = 0.037109375
+A74 = 0.170252211019544039314978060272
+A75 = 0.0602165389804559606850219397283
+A76 = -0.017578125
+
+A81 = 0.0370920001185047927108779319836
+A84 = 0.170383925712239993810214054705
+A85 = 0.107262030446373284651809199168
+A86 = -0.0153194377486244017527936158236
+A87 = 0.00827378916381402288758473766002
+
+A91 = 0.624110958716075717114429577812
+A94 = -3.36089262944694129406857109825
+A95 = -0.868219346841726006818189891453
+A96 = 27.5920996994467083049415600797
+A97 = 20.1540675504778934086186788979
+A98 = -43.4898841810699588477366255144
+
+A101 = 0.477662536438264365890433908527
+A104 = -2.48811461997166764192642586468
+A105 = -0.590290826836842996371446475743
+A106 = 21.2300514481811942347288949897
+A107 = 15.2792336328824235832596922938
+A108 = -33.2882109689848629194453265587
+A109 = -0.0203312017085086261358222928593
+
+A111 = -0.93714243008598732571704021658
+A114 = 5.18637242884406370830023853209
+A115 = 1.09143734899672957818500254654
+A116 = -8.14978701074692612513997267357
+A117 = -18.5200656599969598641566180701
+A118 = 22.7394870993505042818970056734
+A119 = 2.49360555267965238987089396762
+A1110 = -3.0467644718982195003823669022
+
+A121 = 2.27331014751653820792359768449
+A124 = -10.5344954667372501984066689879
+A125 = -2.00087205822486249909675718444
+A126 = -17.9589318631187989172765950534
+A127 = 27.9488845294199600508499808837
+A128 = -2.85899827713502369474065508674
+A129 = -8.87285693353062954433549289258
+A1210 = 12.3605671757943030647266201528
+A1211 = 0.643392746015763530355970484046

yennefer-0.2.0/yennefer/rk4.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from typing import Callable
+
+import numpy as np
+from numpy.typing import NDArray
+from numba import njit
+
+
+F = Callable[[float, NDArray[np.float64], NDArray[np.float64]], NDArray[np.float64]]
+
+
+@njit
+def _rk4_step(
+    f: F,
+    t: float,
+    y: NDArray[np.float64],
+    dt: float,
+    params: NDArray[np.float64],
+) -> NDArray[np.float64]:
+    k1 = f(t,             y,              params)
+    k2 = f(t + 0.5 * dt,  y + 0.5*dt*k1, params)
+    k3 = f(t + 0.5 * dt,  y + 0.5*dt*k2, params)
+    k4 = f(t + dt,        y +      dt*k3, params)
+    return y + (dt / 6.0) * (k1 + 2.0*k2 + 2.0*k3 + k4)
+
+
+@njit
+def _rk4_integrate(
+    f: F,
+    y0: NDArray[np.float64],
+    dt: float,
+    t_max: float,
+    params: NDArray[np.float64],
+) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+    n_steps = int(t_max / dt) + 1
+    n_vars  = y0.shape[0]
+
+    t_arr = np.empty(n_steps, dtype=np.float64)
+    y_arr = np.empty((n_steps, n_vars), dtype=np.float64)
+
+    t_arr[0]  = 0.0
+    y_arr[0]  = y0
+
+    for i in range(1, n_steps):
+        t_arr[i] = t_arr[i - 1] + dt
+        y_arr[i] = _rk4_step(f, t_arr[i - 1], y_arr[i - 1], dt, params)
+
+    return t_arr, y_arr
+
+
+class RK4Solver:
+    """Fixed-step Runge-Kutta 4th-order ODE solver.
+
+    The right-hand side ``f`` must have the signature::
+
+        f(t: float, y: NDArray[float64], params: NDArray[float64]) -> NDArray[float64]
+
+    Both ``_rk4_step`` and ``_rk4_integrate`` are decorated with ``@njit``
+    and are compiled on the first call.  For maximum performance, decorate
+    ``f`` with ``@njit`` as well before passing it to the solver.
+    """
+
+    def __init__(
+        self,
+        function: F,
+        y0:       NDArray[np.float64],
+        params:   NDArray[np.float64],
+    ) -> None:
+        self._f      = function
+        self._y0     = np.asarray(y0,     dtype=np.float64)
+        self._params = np.asarray(params, dtype=np.float64)
+
+        self._t: NDArray[np.float64] | None = None
+        self._y: NDArray[np.float64] | None = None
+
+    def solve(self, t_max: float, dt: float) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+        """Run the integration from ``t = 0`` to ``t_max``.
+
+        Returns
+        -------
+        t : NDArray[float64], shape (N,)
+            Time grid.
+        y : NDArray[float64], shape (N, n_vars)
+            Solution at each time point.
+        """
+        self._t, self._y = _rk4_integrate(
+            self._f, self._y0, dt, t_max, self._params
+        )
+        return self._t, self._y
+
+    @property
+    def t(self) -> NDArray[np.float64]:
+        """Time grid from the last ``solve()`` call."""
+        if self._t is None:
+            raise RuntimeError("Call solve() first.")
+        return self._t
+
+    @property
+    def y(self) -> NDArray[np.float64]:
+        """Solution array from the last ``solve()`` call, shape (N, n_vars)."""
+        if self._y is None:
+            raise RuntimeError("Call solve() first.")
+        return self._y

yennefer-0.2.0/yennefer/rk45.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+from typing import Callable
+
+import numpy as np
+from numpy.typing import NDArray
+from numba import njit
+
+F = Callable[[float, NDArray[np.float64], NDArray[np.float64]], NDArray[np.float64]]
+
+
+@njit
+def _rkf45_step(
+        f: F,
+        t: float,
+        y: NDArray[np.float64],
+        dt: float,
+        params: NDArray[np.float64],
+) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+    k1 = f(t, y, params)
+    k2 = f(t + 0.25 * dt, y + dt * (0.25 * k1), params)
+    k3 = f(t + 0.375 * dt, y + dt * (3.0 / 32.0 * k1 + 9.0 / 32.0 * k2), params)
+    k4 = f(t + (12.0 / 13.0) * dt, y + dt * (1932.0 / 2197.0 * k1 - 7200.0 / 2197.0 * k2 + 7296.0 / 2197.0 * k3),
+           params)
+    k5 = f(t + dt, y + dt * (439.0 / 216.0 * k1 - 8.0 * k2 + 3680.0 / 513.0 * k3 - 845.0 / 4104.0 * k4), params)
+    k6 = f(t + 0.5 * dt,
+           y + dt * (-8.0 / 27.0 * k1 + 2.0 * k2 - 3544.0 / 2565.0 * k3 + 1859.0 / 4104.0 * k4 - 11.0 / 40.0 * k5),
+           params)
+
+    y5 = y + dt * (
+                16.0 / 135.0 * k1 + 6656.0 / 12825.0 * k3 + 28561.0 / 56430.0 * k4 - 9.0 / 50.0 * k5 + 2.0 / 55.0 * k6)
+
+    y4 = y + dt * (25.0 / 216.0 * k1 + 1408.0 / 2565.0 * k3 + 2197.0 / 4104.0 * k4 - 1.0 / 5.0 * k5)
+
+    y_err = y5 - y4
+
+    return y5, y_err
+
+
+@njit
+def _rkf45_integrate(
+        f: F,
+        y0: NDArray[np.float64],
+        dt_initial: float,
+        t_max: float,
+        params: NDArray[np.float64],
+        atol: float,
+        rtol: float,
+        max_step: float,
+) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+    n_vars = y0.shape[0]
+
+    capacity = 1000
+    t_arr = np.empty(capacity, dtype=np.float64)
+    y_arr = np.empty((capacity, n_vars), dtype=np.float64)
+
+    t_arr[0] = 0.0
+    y_arr[0] = y0
+
+    t = 0.0
+    y = y0
+    dt = dt_initial
+    step_idx = 1
+
+    while t < t_max:
+        if t + dt > t_max:
+            dt = t_max - t
+
+        y_new, y_err = _rkf45_step(f, t, y, dt, params)
+
+        scale = atol + np.maximum(np.abs(y), np.abs(y_new)) * rtol
+        error_norm = np.max(np.abs(y_err) / scale)
+
+        if error_norm <= 1.0:
+            t = t + dt
+            y = y_new
+
+            if step_idx >= capacity:
+                new_capacity = capacity * 2
+                new_t_arr = np.empty(new_capacity, dtype=np.float64)
+                new_y_arr = np.empty((new_capacity, n_vars), dtype=np.float64)
+                new_t_arr[:capacity] = t_arr
+                new_y_arr[:capacity] = y_arr
+                t_arr = new_t_arr
+                y_arr = new_y_arr
+                capacity = new_capacity
+
+            t_arr[step_idx] = t
+            y_arr[step_idx] = y
+            step_idx += 1
+
+        if error_norm == 0.0:
+            factor = 5.0
+        else:
+            factor = 0.9 * (1.0 / error_norm) ** 0.25
+
+        factor = min(5.0, max(0.1, factor))
+        dt = dt * factor
+
+        if dt > max_step:
+            dt = max_step
+
+    return t_arr[:step_idx], y_arr[:step_idx]
+
+
+class RK45Solver:
+    """Adaptive-step Runge-Kutta-Fehlberg 4(5) ODE solver.
+
+    The right-hand side ``f`` must have the signature::
+
+        f(t: float, y: NDArray[float64], params: NDArray[float64]) -> NDArray[float64]
+
+    Both ``_rkf45_step`` and ``_rkf45_integrate`` are decorated with ``@njit``
+    and are compiled on the first call. For maximum performance, decorate
+    ``f`` with ``@njit`` as well before passing it to the solver.
+    """
+
+    def __init__(
+            self,
+            function: F,
+            y0: NDArray[np.float64],
+            params: NDArray[np.float64],
+            atol: float = 1e-6,
+            rtol: float = 1e-3,
+            max_step: float = np.inf,
+    ) -> None:
+        self._f = function
+        self._y0 = np.asarray(y0, dtype=np.float64)
+        self._params = np.asarray(params, dtype=np.float64)
+
+        self.rtol = rtol
+        self.atol = atol
+        self.max_step = max_step
+
+        self._t: NDArray[np.float64] | None = None
+        self._y: NDArray[np.float64] | None = None
+
+    def solve(
+            self,
+            t_max: float,
+            dt_initial: float = 1e-3,
+    ) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+        """Run the adaptive integration from ``t = 0`` to ``t_max``.
+
+        Parameters
+        ----------
+        t_max : float
+            Maximum integration time.
+        dt_initial : float, optional
+            Initial step size guess, by default 1e-3.
+        atol : float, optional
+            Absolute tolerance for error control, by default 1e-6.
+        rtol : float, optional
+            Relative tolerance for error control, by default 1e-3.
+        max_step : float, optional
+            Maximum allowed step size, by default infinity.
+
+        Returns
+        -------
+        t : NDArray[float64], shape (N,)
+            Time grid (adaptively determined).
+        y : NDArray[float64], shape (N, n_vars)
+            Solution at each time point.
+        """
+        self._t, self._y = _rkf45_integrate(
+            self._f, self._y0, dt_initial, t_max, self._params, self.atol, self.rtol, self.max_step
+        )
+        return self._t, self._y
+
+    @property
+    def t(self) -> NDArray[np.float64]:
+        """Time grid from the last ``solve()`` call."""
+        if self._t is None:
+            raise RuntimeError("Call solve() first.")
+        return self._t
+
+    @property
+    def y(self) -> NDArray[np.float64]:
+        """Solution array from the last ``solve()`` call, shape (N, n_vars)."""
+        if self._y is None:
+            raise RuntimeError("Call solve() first.")
+        return self._y

yennefer-0.2.0/yennefer.egg-info/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: yennefer
+Version: 0.2.0
+Summary: Fast numerical ODE solvers (RK4, RK45, DOP853) optimized with Numba.
+Author-email: "Gregory Shipunov (aka GrindelfP.)" <grindelf.perlomutrovij@gmail.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: numba
+Dynamic: license-file
+
+# YENNEFER ODE SOLVER 
+
+## Description
+
+This is an ordinary differential equations systems solver library named Yen (after Yennefer of Vengerberg). Fast numerical ODE solvers (RK4, RK45, DOP853) optimized with Numba.

yennefer-0.2.0/yennefer.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+yennefer/__init__.py
+yennefer/dop853.py
+yennefer/dop853_constants.py
+yennefer/rk4.py
+yennefer/rk45.py
+yennefer.egg-info/PKG-INFO
+yennefer.egg-info/SOURCES.txt
+yennefer.egg-info/dependency_links.txt
+yennefer.egg-info/requires.txt
+yennefer.egg-info/top_level.txt

yennefer-0.2.0/yennefer.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

yennefer-0.2.0/yennefer.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy
+numba

yennefer-0.2.0/yennefer.egg-info/top_level.txt

@@ -0,0 +1 @@
+yennefer