mxlpy-native 0.1.0__tar.gz → 0.2.0__tar.gz

mxlpy_native-0.2.0/MANIFEST.in

@@ -0,0 +1 @@
+include c/*.c c/vendor/*.c c/vendor/*.h c/vendor/*.txt c/vendor/VENDORED

{mxlpy_native-0.1.0/src/mxlpy_native.egg-info → mxlpy_native-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mxlpy-native
-Version: 0.1.0
-Summary: Compiled ODE solver for MxlPy's Native integrator
+Version: 0.2.0
+Summary: Compiled ODE solvers for MxlPy's Native integrator
 License-Expression: MIT
 Requires-Python: >=3.12

mxlpy_native-0.2.0/README.md

@@ -0,0 +1,5 @@
+# mxlpy-native
+
+The compiled Radau and LSODA solvers behind MxlPy's `Native` integrator. Install it with `pip install "mxlpy[native]"`, not on its own.
+
+`c/vendor/` is copied from [mxl-solvers](https://github.com/Computational-Biology-Aachen/mxl-solvers) by its `scripts/vendor.sh`. `vendor/VENDORED` records the commit and file hashes, which `tests/integrators/test_native_vendor.py` checks. Fix solvers there, not here. `c/mxn_solvers.c` is MxlPy's own glue, compiled unchanged into both the wheel and `solvers.wasm`.

mxlpy_native-0.1.0/c/mxn_radau.c → mxlpy_native-0.2.0/c/mxn_solvers.c

@@ -1,7 +1,9 @@
-/* RADAU5 for MxlPy's Native integrator, returning values at requested time points.
- * The same source builds the native wheel and radau.wasm. Solver state is global,
- * so only one solve can run at a time in a process. */
+/* RADAU5 and LSODA for MxlPy's Native integrator, returning values at requested time
+ * points. The same source builds the native wheel and solvers.wasm. The solvers
+ * themselves are vendored from mxl-solvers (see vendor/VENDORED). RADAU5 and this
+ * file keep global state, so only one solve can run at a time in a process. */
 #include "f2c.h"
+#include "lsoda.h"
 #include <math.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ -23,6 +25,7 @@ extern double radau5_jac_growth;
 
 typedef void (*ModelFn)(int, double, double *, double *, double *);
 static ModelFn g_model;
+static double *g_pars; /* LSODA's right-hand side takes no parameter array. */
 static const double *g_t_out;
 static double *g_y_out;
 static int g_n_out, g_next;
@@ -100,6 +103,59 @@ MXN_API int mxn_radau(int n, double *y, double *pars, double rtol, double atol,
     return (int)idid;
 }
 
+static void lsoda_fcn(int *n, double *t, double *y, double *dydt) { g_model(*n, *t, y, dydt, g_pars); }
+
+/* Same contract as mxn_radau, with LSODA (SciPy's C translation) and its internal
+ * finite-difference Jacobian. nmax caps the total number of steps. Returns 2 on
+ * success, or LSODA's negative ISTATE: -1 too many steps, -2 too much accuracy
+ * requested, -3 bad input, -4 repeated error test failures, -5 repeated convergence
+ * failures, -6 an error weight became zero. Returns -9 if allocation fails or the
+ * result isn't finite. */
+MXN_API int mxn_lsoda(int n, double *y, double *pars, double rtol, double atol, int nmax, int n_out,
+                      const double *t_out, double *y_out) {
+    /* Work array sizes as in SciPy's odepack: Adams up to order 12, BDF up to 5. */
+    const int lrn = 20 + n * 13 + 3 * n, lrs = 20 + n * 6 + 3 * n + n * n + 2;
+    const int lrw = lrn > lrs ? lrn : lrs, liw = 20 + n;
+    double *rwork = calloc((size_t)lrw, sizeof(double));
+    int *iwork = calloc((size_t)liw, sizeof(int));
+    if (!rwork || !iwork) {
+        free(rwork);
+        free(iwork);
+        return -9;
+    }
+    int itask = 1, istate = 1, iopt = 1;
+    iwork[5] = nmax; /* IWORK(6): steps allowed per output point */
+    lsoda_common_struct_t S = {0};
+    double t = t_out[0];
+    g_pars = pars;
+    memcpy(y_out, y, (size_t)n * sizeof(double));
+    for (int k = 1; k < n_out && istate > 0; k++) {
+        double tout = t_out[k];
+        if (tout != t_out[k - 1]) {
+            lsoda(lsoda_fcn, n, y, &t, &tout, 1, &rtol, &atol, &itask, &istate, &iopt, rwork, lrw, iwork, liw, NULL,
+                  2, &S);
+            if (istate > 0 && iwork[10] > nmax) istate = -1; /* IWORK(11): steps so far */
+        }
+        memcpy(y_out + (size_t)k * (size_t)n, y, (size_t)n * sizeof(double));
+    }
+    free(rwork);
+    free(iwork);
+    if (istate < 0) return istate;
+    for (int i = 0; i < n; i++) {
+        if (!isfinite(y[i])) return -9;
+    }
+    return 2;
+}
+
+/* Evaluates fn once per row of y, writing n_out values per row into out. */
+MXN_API void mxn_eval_rows(intptr_t fn, int n, int n_out, int rows, const double *t, double *y, double *out,
+                           double *pars) {
+    ModelFn f = (ModelFn)fn;
+    for (int r = 0; r < rows; r++) {
+        f(n, t[r], y + (size_t)r * (size_t)n, out + (size_t)r * (size_t)n_out, pars);
+    }
+}
+
 #ifdef MXN_WASM
 /* Model math stays inside wasm, rather than calling back into Python. */
 #define F1(name) double mxn_##name(double x) { return name(x); }
@@ -109,5 +165,5 @@ double mxn_pow(double a, double b) { return pow(a, b); }
 #else
 /* Loaded with ctypes, but setuptools builds it as an extension and Windows linkers
  * insist on this symbol. It's never imported. */
-MXN_API void PyInit__radau(void) {}
+MXN_API void PyInit__solvers(void) {}
 #endif

mxlpy_native-0.2.0/c/vendor/SCIPY-LICENCE.txt

@@ -0,0 +1,30 @@
+Copyright (c) 2001-2002 Enthought, Inc. 2003, SciPy Developers.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. 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.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may 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
+OWNER 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.

mxlpy_native-0.2.0/c/vendor/VENDORED

@@ -0,0 +1,13 @@
+# Vendored from https://github.com/Computational-Biology-Aachen/mxl-solvers at 497e21745295b74821db0e1b836812edbc180e29.
+# Don't edit these files here: change mxl-solvers, then re-run its scripts/vendor.sh.
+da5d9b896c422aa002b6d8fc3c7003a6e6345454afd700ae65fa3cd944ab12e5  radau5.c
+8d2173c6ae898e77a71c2dc52e027ce2b6185d91170bd5f031b185aff6e1d354  dc_decsol.c
+9dc2c0ede63b1511813fbde4300c23a6c1e0536e4d316c6fd5492ae0f20d8195  decsol.c
+cf5d31866e63553809a79416b6baa957be45e3c03a5da59254fbbb317c735cfc  f2c.h
+5ab404a0cbf7e02c21105b9f8322cb65ef78e10f40937740a9cc90b36796b8b8  libf2c_stubs.c
+2f05643511057c06ceed0d8a1d7181857f93a759a60139d7506a4b6123654ac7  lsoda.c
+751d5aa397f303b491d78f689dbf5b779f32b2d158b58c2b861d58143702e1f9  lsoda.h
+8076d5b1bd27484ce6214cc5f9df7d6c88225182498538c9a878ed14d1743836  blaslapack_declarations.h
+c615cf28e6d41f150f631d0b7fa73f6b2d8b694a88818a38851f54b0efec042c  mxs_lapack.c
+49bcfad0e3bbe5c3a0428624254567f32786948332a3204fc1e35b8b2a02b0fd  HAIRER-LICENCE.txt
+221e59f5e910fd7f94e44f0dac77436a11338c285c6346232e4a850a50da0e94  SCIPY-LICENCE.txt

mxlpy_native-0.2.0/c/vendor/blaslapack_declarations.h

@@ -0,0 +1,16 @@
+/* Replaces SciPy's header of the same name, so lsoda.c and lsoda.h compile unchanged
+ * without BLAS or LAPACK. The routines come from mxs_lapack.c, under an mxs_ prefix
+ * so they never clash with a real BLAS loaded in the same process. */
+#ifndef BLASLAPACK_DECLARATIONS_H
+#define BLASLAPACK_DECLARATIONS_H
+
+#define CBLAS_INT int
+#define BLAS_FUNC(name) mxs_##name
+
+void mxs_dgetrf(int *m, int *n, double *a, int *lda, int *ipiv, int *info);
+void mxs_dgetrs(char *trans, int *n, int *nrhs, double *a, int *lda, int *ipiv, double *b, int *ldb, int *info);
+void mxs_dgbtrf(int *m, int *n, int *kl, int *ku, double *ab, int *ldab, int *ipiv, int *info);
+void mxs_dgbtrs(char *trans, int *n, int *kl, int *ku, int *nrhs, double *ab, int *ldab, int *ipiv, double *b,
+                int *ldb, int *info);
+
+#endif