mathematicskit 0.4.0__tar.gz → 0.5.0__tar.gz

{mathematicskit-0.4.0 → mathematicskit-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathematicskit
-Version: 0.4.0
+Version: 0.5.0
 Summary: Unified computational mathematics toolkit: numerical analysis, linear algebra, calculus, dynamical systems, partial differential equations, optimization, probability, statistics, number theory, combinatorics, complex analysis, graph theory, abstract algebra, geometry, special functions, and fractals/chaos -- built on numpy/scipy, hand-rolling algorithms only where no library equivalent exists.
 Author-email: Charles Poli <cpoli374@gmail.com>
 Maintainer-email: Charles Poli <cpoli374@gmail.com>
@@ -58,20 +58,20 @@ Dynamic: license-file
 | | |
 |:--|:-:|
 | Package | [![PyPI version](https://img.shields.io/pypi/v/mathematicskit)](https://pypi.org/project/mathematicskit/) [![Python versions](https://img.shields.io/pypi/pyversions/mathematicskit)](https://pypi.org/project/mathematicskit/) |
-| Quality | [![License](https://img.shields.io/github/license/cpoli/mathematicskit)](https://github.com/cpoli/mathematicskit/blob/main/LICENSE) [![CI](https://github.com/cpoli/mathematicskit/actions/workflows/ci.yml/badge.svg)](https://github.com/cpoli/mathematicskit/actions/workflows/ci.yml) [![Coverage](https://img.shields.io/codecov/c/github/cpoli/mathematicskit)](https://codecov.io/gh/cpoli/mathematicskit) [![Coverage (manual)](https://img.shields.io/badge/coverage-96%25-brightgreen)](#coverage) |
+| Quality | [![License](https://img.shields.io/github/license/cpoli/mathematicskit)](https://github.com/cpoli/mathematicskit/blob/main/LICENSE) [![CI](https://github.com/cpoli/mathematicskit/actions/workflows/ci.yml/badge.svg)](https://github.com/cpoli/mathematicskit/actions/workflows/ci.yml) [![Coverage](https://img.shields.io/codecov/c/github/cpoli/mathematicskit)](https://codecov.io/gh/cpoli/mathematicskit) [![Coverage (manual)](https://img.shields.io/badge/coverage-99%25-brightgreen)](#coverage) |
 | Documentation | [![Docs](https://img.shields.io/badge/docs-cpoli.github.io%2Fmathematicskit-blue)](https://cpoli.github.io/mathematicskit/) |
 | Code style | [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff) |
 | Downloads | [![Downloads](https://static.pepy.tech/badge/mathematicskit)](https://pepy.tech/project/mathematicskit) [![Downloads/Month](https://static.pepy.tech/badge/mathematicskit/month)](https://pepy.tech/project/mathematicskit) |
 | Community | [![GitHub Stars](https://img.shields.io/github/stars/cpoli/mathematicskit?style=social)](https://github.com/cpoli/mathematicskit) [![GitHub Forks](https://img.shields.io/github/forks/cpoli/mathematicskit?style=social)](https://github.com/cpoli/mathematicskit) [![Contributors](https://img.shields.io/github/contributors/cpoli/mathematicskit)](https://github.com/cpoli/mathematicskit/graphs/contributors) [![Last Commit](https://img.shields.io/github/last-commit/cpoli/mathematicskit)](https://github.com/cpoli/mathematicskit/commits/main) |
-| Try it online | [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/cpoli/mathematicskit/blob/main/notebooks/quickstart.ipynb) [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/cpoli/mathematicskit/main?labpath=notebooks%2Fquickstart.ipynb) [![JupyterLite](https://jupyterlite.rtfd.io/en/latest/_static/badge.svg)](https://cpoli.github.io/mathematicskit/lite/lab/) |
+| Try it online | [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/cpoli/mathematicskit/blob/main/notebooks/quickstart.ipynb) [![JupyterLite](https://jupyterlite.rtfd.io/en/latest/_static/badge.svg)](https://cpoli.github.io/mathematicskit/lite/lab/) |
 
 **See how the algorithms of computational mathematics actually work.**
 mathematicskit is a Python toolkit for learning and teaching numerical
-methods, dynamical systems, and discrete mathematics. Every iterative method
-keeps its iterates, every result is an inspectable dataclass, every domain
-ships plotting helpers, and each domain's docs walk through the field's
-breakthroughs in historical order, each one linked to runnable code that
-reproduces it.
+methods, dynamical systems, and discrete mathematics. No black boxes: every
+iterative method shows its work, every result is an inspectable dataclass,
+every domain ships plotting helpers, and each domain's docs walk through the
+field's breakthroughs in historical order, each one linked to runnable code
+that reproduces it.
 
 ![Mandelbrot set, Newton vs. bisection convergence, and the logistic-map bifurcation diagram, all drawn with mathematicskit](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_hero.png)
 
@@ -123,36 +123,85 @@ ax.legend()
 ```
 
 The [quickstart notebook](https://github.com/cpoli/mathematicskit/blob/main/notebooks/quickstart.ipynb) tours six domains in
-ten minutes. Open it in Colab or Binder using the badges above.
+ten minutes. Open it in Colab using the badge above.
 
 ## Subpackages
 
 Domain subpackages, each with runnable examples linked below:
 
-- [`mathematicskit.numerical_analysis`](https://cpoli.github.io/mathematicskit/api/gallery/numerical_analysis/) -- root finding (bisection, Newton-Raphson, secant, fixed-point, hand-rolled for their convergence history), Lagrange/Newton (hand-rolled) plus scipy-backed cubic-spline interpolation, numpy-backed Chebyshev nodes, `numpy.linalg.lstsq`-based polynomial regression, and `numpy.linalg.cond`-based error/condition-number analysis.
+- [`mathematicskit.numerical_analysis`](https://cpoli.github.io/mathematicskit/api/gallery/numerical_analysis/) -- root finding (bisection, Newton-Raphson, secant, fixed-point, hand-rolled for their convergence history), Newton's and Broyden's methods for nonlinear systems, Lagrange/Newton (hand-rolled) plus scipy-backed cubic-spline interpolation, numpy-backed Chebyshev nodes, `numpy.linalg.lstsq`-based polynomial regression, floating-point arithmetic (IEEE 754 bit fields, machine epsilon, catastrophic cancellation), and `numpy.linalg.cond`-based error/condition-number analysis.
+
+  ![Runge's phenomenon, its Chebyshev-node cure, and Bernstein polynomial approximation](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_numerical_analysis.png)
+
 - [`mathematicskit.linalg`](https://cpoli.github.io/mathematicskit/api/gallery/linalg/) -- LU/QR/Cholesky decompositions and eigenvalue computation via `scipy.linalg`/`numpy.linalg`, power/inverse iteration (hand-rolled), SVD, conjugate gradient and GMRES via `scipy.sparse.linalg`, and least-squares stability (normal equations vs. QR vs. `numpy.linalg.lstsq`).
+
+  ![SVD low-rank approximations, Gershgorin discs, and conjugate-gradient vs. GMRES residuals](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_linalg.png)
+
 - [`mathematicskit.calculus`](https://cpoli.github.io/mathematicskit/api/gallery/calculus/) -- finite-difference derivatives with Richardson extrapolation (hand-rolled), `scipy.integrate`-backed trapezoidal/Simpson/Gauss-Legendre/adaptive quadrature, forward-mode (dual numbers) and reverse-mode (backpropagation) automatic differentiation (hand-rolled), and Taylor/Maclaurin series.
+
+  ![A midpoint Riemann sum, Taylor polynomials of sin, and adaptive quadrature sample points](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_calculus.png)
+
 - [`mathematicskit.ode_dynamics`](https://cpoli.github.io/mathematicskit/api/gallery/ode_dynamics/) -- Jacobian-linearization fixed-point stability (node/saddle/spiral/center), phase portraits, the logistic map's Feigenbaum route to chaos, saddle-node/pitchfork/Hopf bifurcation normal forms, the Van der Pol limit cycle, and Poincare sections of the driven Duffing oscillator.
+
+  ![Pendulum phase portrait, the Lorenz attractor, and a Poincaré section of the Duffing oscillator](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_ode_dynamics.png)
+
 - [`mathematicskit.pde`](https://cpoli.github.io/mathematicskit/api/gallery/pde/) -- the heat equation in 1D and 2D by the method of lines on `mathematicskit.integrators` and by the theta-method family (FTCS, Crank-Nicolson, backward Euler via `scipy.sparse.linalg.splu`); the wave equation with symplectic leapfrog stepping against d'Alembert's solution; upwind, Lax-Friedrichs and Lax-Wendroff advection; Poisson/Laplace problems solved with `scipy.sparse.linalg.spsolve` or `mathematicskit.linalg`'s CG/Jacobi/Gauss-Seidel/SOR; CFL checks and von Neumann amplification factors; and Fourier (`numpy.fft`) and Chebyshev spectral methods.
+
+  ![2D heat equation, wave-equation space-time diagram, and a Burgers shock](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_pde.png)
+
 - [`mathematicskit.fractals_chaos`](https://cpoli.github.io/mathematicskit/api/gallery/fractals_chaos/) -- Lyapunov exponent estimation, box-counting fractal dimension, Numba-accelerated Mandelbrot/Julia set generation, iterated function systems (Barnsley fern, Sierpinski triangle/carpet), and cellular automata (Wolfram rules, Conway's Game of Life).
+
+  ![Barnsley's fern, a Julia set, and Wolfram's rule 30](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_fractals_chaos.png)
+
 - [`mathematicskit.optimization`](https://cpoli.github.io/mathematicskit/api/gallery/optimization/) -- gradient descent and nonlinear conjugate gradient (hand-rolled, iterate-path-exposing), Newton's method and BFGS via `scipy.optimize.minimize`, Lagrange multipliers and KKT-condition verification, a quadratic-penalty method, and linear programming via `scipy.optimize.linprog`.
+
+  ![Optimizer paths on Rosenbrock's function, CG vs. gradient descent convergence, and a linear program](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_optimization.png)
+
 - [`mathematicskit.probability`](https://cpoli.github.io/mathematicskit/api/gallery/probability/) -- binomial/Poisson/geometric/uniform/exponential/normal/gamma distributions via `scipy.stats` (plus mathematicskit's own MGFs), Monte Carlo integration with variance reduction (importance sampling, control variates), Law of Large Numbers/Central Limit Theorem simulation, and discrete-time Markov chains.
+
+  ![Central limit theorem histogram, Brownian motion paths, and Monte Carlo integration](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_probability.png)
+
 - [`mathematicskit.statistics`](https://cpoli.github.io/mathematicskit/api/gallery/statistics/) -- descriptive statistics, z/t/chi-square hypothesis tests and one-way ANOVA, confidence intervals for means/proportions/variances, OLS linear regression with residual diagnostics, and bootstrap resampling via `scipy.stats.bootstrap`.
+
+  ![Regression fit, OLS residuals, and group box plots](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_statistics.png)
+
 - [`mathematicskit.number_theory`](https://cpoli.github.io/mathematicskit/api/gallery/number_theory/) -- the extended Euclidean algorithm and modular inverses, fast modular exponentiation, primality testing (trial division, Miller-Rabin) and prime generation, the Chinese Remainder Theorem, continued fractions and best rational approximations, Euler's totient/Mobius/divisor-sum functions, and linear/Pell Diophantine equation solvers (hand-rolled -- exact-integer number theory has no `numpy`/`scipy` equivalent).
+
+  ![Prime-counting function, continued-fraction convergents of pi, and Fermat's two-squares primes](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_number_theory.png)
+
 - [`mathematicskit.combinatorics`](https://cpoli.github.io/mathematicskit/api/gallery/combinatorics/) -- permutation/combination counting via `scipy.special.perm`/`comb` (sequence generation via `itertools`), a hand-rolled Pascal's triangle, integer partitions and Young/Ferrers diagrams, the inclusion-exclusion principle and derangements, and Stirling/Catalan/Bell numbers (hand-rolled -- no scipy/numpy equivalent).
+
+  ![Pascal's triangle, Pascal's triangle mod 2, and the partition function](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_combinatorics.png)
+
 - [`mathematicskit.complex_analysis`](https://cpoli.github.io/mathematicskit/api/gallery/complex_analysis/) -- the Cauchy-Riemann equations, contour integrals via `scipy.integrate.quad` (`complex_func=True`), winding numbers and Cauchy's integral formula, residues (periodic trapezoidal rule), the residue theorem and the argument principle, conformal maps (Möbius transformations, Joukowski airfoils), and domain coloring.
+
+  ![Domain coloring, Joukowski airfoils, and residue-theorem contours](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_complex_analysis.png)
+
 - [`mathematicskit.graph_theory`](https://cpoli.github.io/mathematicskit/api/gallery/graph_theory/) -- a lightweight own graph container (no `networkx`); shortest paths (Dijkstra/Bellman-Ford/Floyd-Warshall) and minimum spanning tree (Kruskal) via `scipy.sparse.csgraph`, with a hand-rolled Prim's kept for comparison; maximum flow/minimum cut via `scipy.sparse.csgraph.maximum_flow`; hand-rolled graph coloring (greedy, exact backtracking); and spectral graph theory (Laplacian via scipy, eigendecomposition via `numpy.linalg.eigh`).
+
+  ![Spectral bipartition, A* search, and a four-colored map](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_graph_theory.png)
+
 - [`mathematicskit.abstract_algebra`](https://cpoli.github.io/mathematicskit/api/gallery/abstract_algebra/) -- cyclic and permutation groups with Cayley tables and group-property checks, subgroup/coset enumeration, finite field arithmetic (`GF(p)`/`GF(p^n)` via irreducible polynomials), and polynomial ring arithmetic over Z/Q/finite fields (hand-rolled throughout -- no scipy/numpy equivalent).
+
+  ![Cayley tables of D4 and S4 and the multiplication table of GF(16)](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_abstract_algebra.png)
+
 - [`mathematicskit.geometry`](https://cpoli.github.io/mathematicskit/api/gallery/geometry/) -- convex hull via `scipy.spatial.ConvexHull` (with a hand-rolled Graham scan comparison), Delaunay triangulation/Voronoi diagrams via `scipy.spatial`, hand-rolled segment intersection and point-in-polygon tests, polygon area/centroid via the shoelace formula, and curvature/arc-length/the Frenet-Serret frame for parametric curves.
+
+  ![Voronoi diagram, Delaunay triangulation, and a Bézier curve by de Casteljau](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_geometry.png)
+
 - [`mathematicskit.special_functions`](https://cpoli.github.io/mathematicskit/api/gallery/special_functions/) -- the gamma/beta functions and Bessel functions via `scipy.special`, orthogonal polynomial families (Legendre/Chebyshev/Hermite/Laguerre) via `numpy.polynomial` with numerically-verified orthogonality, the discrete Fourier transform via `numpy.fft` alongside a hand-rolled naive-DFT-vs-radix-2-FFT pedagogical speed comparison, and signal processing: direct/FFT convolution and Butterworth/Chebyshev/window-FIR filters via `scipy.signal`, the Z-transform with partial-fraction inversion, the Laplace transform with hand-rolled Talbot/Gaver-Stehfest numerical inversion, and hand-rolled Daubechies wavelets, the discrete wavelet transform, and the Morlet continuous wavelet transform (no numpy/scipy equivalent since scipy 1.15).
 
+  ![Bessel functions, a Morlet wavelet scalogram, and the Cornu spiral](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_special_functions.png)
+
+
 Shared infrastructure, used across the subpackages above rather than
 standalone toolkits:
 
 - `mathematicskit.constants` -- mathematical constants and default numerical
   tolerances shared across subpackages.
-- `mathematicskit.integrators` -- shared numerical ODE integrators (RK4,
-  leapfrog, Yoshida4, adaptive Dormand-Prince), used by
+- `mathematicskit.integrators` -- shared numerical ODE integrators (explicit
+  Euler, RK4, Adams-Bashforth, leapfrog, Yoshida4, adaptive
+  Dormand-Prince, backward Euler) and their linear stability regions, used by
   `mathematicskit.ode_dynamics`.
 
 ## Design
@@ -188,34 +237,33 @@ macOS. See [CONTRIBUTING.md](CONTRIBUTING.md) before opening a PR.
 ### Coverage
 
 ```bash
-MPLBACKEND=Agg pytest -q --cov=mathematicskit --cov-report=term
+MPLBACKEND=Agg pytest -q --cov=mathematicskit --cov-report=
+NUMBA_DISABLE_JIT=1 MPLBACKEND=Agg pytest -q --cov=mathematicskit --cov-append --cov-report=term
 ```
 
-1568 tests, 96% line coverage overall (94% excluding the test files
-themselves). Per-subpackage coverage, excluding tests:
+Coverage cannot trace `@njit`-compiled code, so the kernel bodies in
+`ode_dynamics`, `fractals_chaos`, `pde` and `integrators` are only
+covered by the second run, where they execute as plain Python. CI does
+the same: the numba and no-numba jobs both upload to Codecov, which
+merges them. Combined: 1672 tests, 99% line coverage overall (98%
+excluding the test files themselves). Per-subpackage coverage,
+excluding tests:
 
 | Subpackage | Coverage | | Subpackage | Coverage |
 |:--|--:|---|:--|--:|
-| `abstract_algebra` | 97% | | `numerical_analysis` | 95% |
-| `calculus` | 93% | | `ode_dynamics` | 85% |
+| `abstract_algebra` | 97% | | `numerical_analysis` | 96% |
+| `calculus` | 93% | | `ode_dynamics` | 100% |
 | `combinatorics` | 96% | | `optimization` | 99% |
-| `complex_analysis` | 99% | | `pde` | 94% |
-| `fractals_chaos` | 83% | | `probability` | 98% |
+| `complex_analysis` | 99% | | `pde` | 99% |
+| `fractals_chaos` | 100% | | `probability` | 98% |
 | `geometry` | 99% | | `special_functions` | 99% |
 | `graph_theory` | 99% | | `statistics` | 99% |
-| `linalg` | 94% | | `integrators` | 41% |
-| `number_theory` | 97% | | `constants` | 100% |
+| `linalg` | 94% | | `integrators` | 100% |
+| `number_theory` | 98% | | `constants` | 100% |
 
 `visualizers/` modules are smoke-tested only (correct return type/shape,
 or that `anim.save()` succeeds) rather than covered line-by-line, per the
-testing convention in [CLAUDE.md](CLAUDE.md). `integrators` looks low
-only because its bodies are `@njit`-compiled, and coverage cannot trace
-compiled code; every integrator is tested directly, and with the JIT
-disabled the subpackage is fully covered:
-
-```bash
-NUMBA_DISABLE_JIT=1 MPLBACKEND=Agg pytest -q mathematicskit/integrators --cov=mathematicskit.integrators
-```
+testing convention in [CLAUDE.md](CLAUDE.md).
 
 ## Docs
 

{mathematicskit-0.4.0 → mathematicskit-0.5.0}/README.md

@@ -3,20 +3,20 @@
 | | |
 |:--|:-:|
 | Package | [![PyPI version](https://img.shields.io/pypi/v/mathematicskit)](https://pypi.org/project/mathematicskit/) [![Python versions](https://img.shields.io/pypi/pyversions/mathematicskit)](https://pypi.org/project/mathematicskit/) |
-| Quality | [![License](https://img.shields.io/github/license/cpoli/mathematicskit)](https://github.com/cpoli/mathematicskit/blob/main/LICENSE) [![CI](https://github.com/cpoli/mathematicskit/actions/workflows/ci.yml/badge.svg)](https://github.com/cpoli/mathematicskit/actions/workflows/ci.yml) [![Coverage](https://img.shields.io/codecov/c/github/cpoli/mathematicskit)](https://codecov.io/gh/cpoli/mathematicskit) [![Coverage (manual)](https://img.shields.io/badge/coverage-96%25-brightgreen)](#coverage) |
+| Quality | [![License](https://img.shields.io/github/license/cpoli/mathematicskit)](https://github.com/cpoli/mathematicskit/blob/main/LICENSE) [![CI](https://github.com/cpoli/mathematicskit/actions/workflows/ci.yml/badge.svg)](https://github.com/cpoli/mathematicskit/actions/workflows/ci.yml) [![Coverage](https://img.shields.io/codecov/c/github/cpoli/mathematicskit)](https://codecov.io/gh/cpoli/mathematicskit) [![Coverage (manual)](https://img.shields.io/badge/coverage-99%25-brightgreen)](#coverage) |
 | Documentation | [![Docs](https://img.shields.io/badge/docs-cpoli.github.io%2Fmathematicskit-blue)](https://cpoli.github.io/mathematicskit/) |
 | Code style | [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff) |
 | Downloads | [![Downloads](https://static.pepy.tech/badge/mathematicskit)](https://pepy.tech/project/mathematicskit) [![Downloads/Month](https://static.pepy.tech/badge/mathematicskit/month)](https://pepy.tech/project/mathematicskit) |
 | Community | [![GitHub Stars](https://img.shields.io/github/stars/cpoli/mathematicskit?style=social)](https://github.com/cpoli/mathematicskit) [![GitHub Forks](https://img.shields.io/github/forks/cpoli/mathematicskit?style=social)](https://github.com/cpoli/mathematicskit) [![Contributors](https://img.shields.io/github/contributors/cpoli/mathematicskit)](https://github.com/cpoli/mathematicskit/graphs/contributors) [![Last Commit](https://img.shields.io/github/last-commit/cpoli/mathematicskit)](https://github.com/cpoli/mathematicskit/commits/main) |
-| Try it online | [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/cpoli/mathematicskit/blob/main/notebooks/quickstart.ipynb) [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/cpoli/mathematicskit/main?labpath=notebooks%2Fquickstart.ipynb) [![JupyterLite](https://jupyterlite.rtfd.io/en/latest/_static/badge.svg)](https://cpoli.github.io/mathematicskit/lite/lab/) |
+| Try it online | [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/cpoli/mathematicskit/blob/main/notebooks/quickstart.ipynb) [![JupyterLite](https://jupyterlite.rtfd.io/en/latest/_static/badge.svg)](https://cpoli.github.io/mathematicskit/lite/lab/) |
 
 **See how the algorithms of computational mathematics actually work.**
 mathematicskit is a Python toolkit for learning and teaching numerical
-methods, dynamical systems, and discrete mathematics. Every iterative method
-keeps its iterates, every result is an inspectable dataclass, every domain
-ships plotting helpers, and each domain's docs walk through the field's
-breakthroughs in historical order, each one linked to runnable code that
-reproduces it.
+methods, dynamical systems, and discrete mathematics. No black boxes: every
+iterative method shows its work, every result is an inspectable dataclass,
+every domain ships plotting helpers, and each domain's docs walk through the
+field's breakthroughs in historical order, each one linked to runnable code
+that reproduces it.
 
 ![Mandelbrot set, Newton vs. bisection convergence, and the logistic-map bifurcation diagram, all drawn with mathematicskit](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_hero.png)
 
@@ -68,36 +68,85 @@ ax.legend()
 ```
 
 The [quickstart notebook](https://github.com/cpoli/mathematicskit/blob/main/notebooks/quickstart.ipynb) tours six domains in
-ten minutes. Open it in Colab or Binder using the badges above.
+ten minutes. Open it in Colab using the badge above.
 
 ## Subpackages
 
 Domain subpackages, each with runnable examples linked below:
 
-- [`mathematicskit.numerical_analysis`](https://cpoli.github.io/mathematicskit/api/gallery/numerical_analysis/) -- root finding (bisection, Newton-Raphson, secant, fixed-point, hand-rolled for their convergence history), Lagrange/Newton (hand-rolled) plus scipy-backed cubic-spline interpolation, numpy-backed Chebyshev nodes, `numpy.linalg.lstsq`-based polynomial regression, and `numpy.linalg.cond`-based error/condition-number analysis.
+- [`mathematicskit.numerical_analysis`](https://cpoli.github.io/mathematicskit/api/gallery/numerical_analysis/) -- root finding (bisection, Newton-Raphson, secant, fixed-point, hand-rolled for their convergence history), Newton's and Broyden's methods for nonlinear systems, Lagrange/Newton (hand-rolled) plus scipy-backed cubic-spline interpolation, numpy-backed Chebyshev nodes, `numpy.linalg.lstsq`-based polynomial regression, floating-point arithmetic (IEEE 754 bit fields, machine epsilon, catastrophic cancellation), and `numpy.linalg.cond`-based error/condition-number analysis.
+
+  ![Runge's phenomenon, its Chebyshev-node cure, and Bernstein polynomial approximation](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_numerical_analysis.png)
+
 - [`mathematicskit.linalg`](https://cpoli.github.io/mathematicskit/api/gallery/linalg/) -- LU/QR/Cholesky decompositions and eigenvalue computation via `scipy.linalg`/`numpy.linalg`, power/inverse iteration (hand-rolled), SVD, conjugate gradient and GMRES via `scipy.sparse.linalg`, and least-squares stability (normal equations vs. QR vs. `numpy.linalg.lstsq`).
+
+  ![SVD low-rank approximations, Gershgorin discs, and conjugate-gradient vs. GMRES residuals](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_linalg.png)
+
 - [`mathematicskit.calculus`](https://cpoli.github.io/mathematicskit/api/gallery/calculus/) -- finite-difference derivatives with Richardson extrapolation (hand-rolled), `scipy.integrate`-backed trapezoidal/Simpson/Gauss-Legendre/adaptive quadrature, forward-mode (dual numbers) and reverse-mode (backpropagation) automatic differentiation (hand-rolled), and Taylor/Maclaurin series.
+
+  ![A midpoint Riemann sum, Taylor polynomials of sin, and adaptive quadrature sample points](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_calculus.png)
+
 - [`mathematicskit.ode_dynamics`](https://cpoli.github.io/mathematicskit/api/gallery/ode_dynamics/) -- Jacobian-linearization fixed-point stability (node/saddle/spiral/center), phase portraits, the logistic map's Feigenbaum route to chaos, saddle-node/pitchfork/Hopf bifurcation normal forms, the Van der Pol limit cycle, and Poincare sections of the driven Duffing oscillator.
+
+  ![Pendulum phase portrait, the Lorenz attractor, and a Poincaré section of the Duffing oscillator](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_ode_dynamics.png)
+
 - [`mathematicskit.pde`](https://cpoli.github.io/mathematicskit/api/gallery/pde/) -- the heat equation in 1D and 2D by the method of lines on `mathematicskit.integrators` and by the theta-method family (FTCS, Crank-Nicolson, backward Euler via `scipy.sparse.linalg.splu`); the wave equation with symplectic leapfrog stepping against d'Alembert's solution; upwind, Lax-Friedrichs and Lax-Wendroff advection; Poisson/Laplace problems solved with `scipy.sparse.linalg.spsolve` or `mathematicskit.linalg`'s CG/Jacobi/Gauss-Seidel/SOR; CFL checks and von Neumann amplification factors; and Fourier (`numpy.fft`) and Chebyshev spectral methods.
+
+  ![2D heat equation, wave-equation space-time diagram, and a Burgers shock](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_pde.png)
+
 - [`mathematicskit.fractals_chaos`](https://cpoli.github.io/mathematicskit/api/gallery/fractals_chaos/) -- Lyapunov exponent estimation, box-counting fractal dimension, Numba-accelerated Mandelbrot/Julia set generation, iterated function systems (Barnsley fern, Sierpinski triangle/carpet), and cellular automata (Wolfram rules, Conway's Game of Life).
+
+  ![Barnsley's fern, a Julia set, and Wolfram's rule 30](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_fractals_chaos.png)
+
 - [`mathematicskit.optimization`](https://cpoli.github.io/mathematicskit/api/gallery/optimization/) -- gradient descent and nonlinear conjugate gradient (hand-rolled, iterate-path-exposing), Newton's method and BFGS via `scipy.optimize.minimize`, Lagrange multipliers and KKT-condition verification, a quadratic-penalty method, and linear programming via `scipy.optimize.linprog`.
+
+  ![Optimizer paths on Rosenbrock's function, CG vs. gradient descent convergence, and a linear program](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_optimization.png)
+
 - [`mathematicskit.probability`](https://cpoli.github.io/mathematicskit/api/gallery/probability/) -- binomial/Poisson/geometric/uniform/exponential/normal/gamma distributions via `scipy.stats` (plus mathematicskit's own MGFs), Monte Carlo integration with variance reduction (importance sampling, control variates), Law of Large Numbers/Central Limit Theorem simulation, and discrete-time Markov chains.
+
+  ![Central limit theorem histogram, Brownian motion paths, and Monte Carlo integration](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_probability.png)
+
 - [`mathematicskit.statistics`](https://cpoli.github.io/mathematicskit/api/gallery/statistics/) -- descriptive statistics, z/t/chi-square hypothesis tests and one-way ANOVA, confidence intervals for means/proportions/variances, OLS linear regression with residual diagnostics, and bootstrap resampling via `scipy.stats.bootstrap`.
+
+  ![Regression fit, OLS residuals, and group box plots](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_statistics.png)
+
 - [`mathematicskit.number_theory`](https://cpoli.github.io/mathematicskit/api/gallery/number_theory/) -- the extended Euclidean algorithm and modular inverses, fast modular exponentiation, primality testing (trial division, Miller-Rabin) and prime generation, the Chinese Remainder Theorem, continued fractions and best rational approximations, Euler's totient/Mobius/divisor-sum functions, and linear/Pell Diophantine equation solvers (hand-rolled -- exact-integer number theory has no `numpy`/`scipy` equivalent).
+
+  ![Prime-counting function, continued-fraction convergents of pi, and Fermat's two-squares primes](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_number_theory.png)
+
 - [`mathematicskit.combinatorics`](https://cpoli.github.io/mathematicskit/api/gallery/combinatorics/) -- permutation/combination counting via `scipy.special.perm`/`comb` (sequence generation via `itertools`), a hand-rolled Pascal's triangle, integer partitions and Young/Ferrers diagrams, the inclusion-exclusion principle and derangements, and Stirling/Catalan/Bell numbers (hand-rolled -- no scipy/numpy equivalent).
+
+  ![Pascal's triangle, Pascal's triangle mod 2, and the partition function](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_combinatorics.png)
+
 - [`mathematicskit.complex_analysis`](https://cpoli.github.io/mathematicskit/api/gallery/complex_analysis/) -- the Cauchy-Riemann equations, contour integrals via `scipy.integrate.quad` (`complex_func=True`), winding numbers and Cauchy's integral formula, residues (periodic trapezoidal rule), the residue theorem and the argument principle, conformal maps (Möbius transformations, Joukowski airfoils), and domain coloring.
+
+  ![Domain coloring, Joukowski airfoils, and residue-theorem contours](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_complex_analysis.png)
+
 - [`mathematicskit.graph_theory`](https://cpoli.github.io/mathematicskit/api/gallery/graph_theory/) -- a lightweight own graph container (no `networkx`); shortest paths (Dijkstra/Bellman-Ford/Floyd-Warshall) and minimum spanning tree (Kruskal) via `scipy.sparse.csgraph`, with a hand-rolled Prim's kept for comparison; maximum flow/minimum cut via `scipy.sparse.csgraph.maximum_flow`; hand-rolled graph coloring (greedy, exact backtracking); and spectral graph theory (Laplacian via scipy, eigendecomposition via `numpy.linalg.eigh`).
+
+  ![Spectral bipartition, A* search, and a four-colored map](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_graph_theory.png)
+
 - [`mathematicskit.abstract_algebra`](https://cpoli.github.io/mathematicskit/api/gallery/abstract_algebra/) -- cyclic and permutation groups with Cayley tables and group-property checks, subgroup/coset enumeration, finite field arithmetic (`GF(p)`/`GF(p^n)` via irreducible polynomials), and polynomial ring arithmetic over Z/Q/finite fields (hand-rolled throughout -- no scipy/numpy equivalent).
+
+  ![Cayley tables of D4 and S4 and the multiplication table of GF(16)](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_abstract_algebra.png)
+
 - [`mathematicskit.geometry`](https://cpoli.github.io/mathematicskit/api/gallery/geometry/) -- convex hull via `scipy.spatial.ConvexHull` (with a hand-rolled Graham scan comparison), Delaunay triangulation/Voronoi diagrams via `scipy.spatial`, hand-rolled segment intersection and point-in-polygon tests, polygon area/centroid via the shoelace formula, and curvature/arc-length/the Frenet-Serret frame for parametric curves.
+
+  ![Voronoi diagram, Delaunay triangulation, and a Bézier curve by de Casteljau](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_geometry.png)
+
 - [`mathematicskit.special_functions`](https://cpoli.github.io/mathematicskit/api/gallery/special_functions/) -- the gamma/beta functions and Bessel functions via `scipy.special`, orthogonal polynomial families (Legendre/Chebyshev/Hermite/Laguerre) via `numpy.polynomial` with numerically-verified orthogonality, the discrete Fourier transform via `numpy.fft` alongside a hand-rolled naive-DFT-vs-radix-2-FFT pedagogical speed comparison, and signal processing: direct/FFT convolution and Butterworth/Chebyshev/window-FIR filters via `scipy.signal`, the Z-transform with partial-fraction inversion, the Laplace transform with hand-rolled Talbot/Gaver-Stehfest numerical inversion, and hand-rolled Daubechies wavelets, the discrete wavelet transform, and the Morlet continuous wavelet transform (no numpy/scipy equivalent since scipy 1.15).
 
+  ![Bessel functions, a Morlet wavelet scalogram, and the Cornu spiral](https://raw.githubusercontent.com/cpoli/mathematicskit/main/docs/source/_static/images/readme_special_functions.png)
+
+
 Shared infrastructure, used across the subpackages above rather than
 standalone toolkits:
 
 - `mathematicskit.constants` -- mathematical constants and default numerical
   tolerances shared across subpackages.
-- `mathematicskit.integrators` -- shared numerical ODE integrators (RK4,
-  leapfrog, Yoshida4, adaptive Dormand-Prince), used by
+- `mathematicskit.integrators` -- shared numerical ODE integrators (explicit
+  Euler, RK4, Adams-Bashforth, leapfrog, Yoshida4, adaptive
+  Dormand-Prince, backward Euler) and their linear stability regions, used by
   `mathematicskit.ode_dynamics`.
 
 ## Design
@@ -133,34 +182,33 @@ macOS. See [CONTRIBUTING.md](CONTRIBUTING.md) before opening a PR.
 ### Coverage
 
 ```bash
-MPLBACKEND=Agg pytest -q --cov=mathematicskit --cov-report=term
+MPLBACKEND=Agg pytest -q --cov=mathematicskit --cov-report=
+NUMBA_DISABLE_JIT=1 MPLBACKEND=Agg pytest -q --cov=mathematicskit --cov-append --cov-report=term
 ```
 
-1568 tests, 96% line coverage overall (94% excluding the test files
-themselves). Per-subpackage coverage, excluding tests:
+Coverage cannot trace `@njit`-compiled code, so the kernel bodies in
+`ode_dynamics`, `fractals_chaos`, `pde` and `integrators` are only
+covered by the second run, where they execute as plain Python. CI does
+the same: the numba and no-numba jobs both upload to Codecov, which
+merges them. Combined: 1672 tests, 99% line coverage overall (98%
+excluding the test files themselves). Per-subpackage coverage,
+excluding tests:
 
 | Subpackage | Coverage | | Subpackage | Coverage |
 |:--|--:|---|:--|--:|
-| `abstract_algebra` | 97% | | `numerical_analysis` | 95% |
-| `calculus` | 93% | | `ode_dynamics` | 85% |
+| `abstract_algebra` | 97% | | `numerical_analysis` | 96% |
+| `calculus` | 93% | | `ode_dynamics` | 100% |
 | `combinatorics` | 96% | | `optimization` | 99% |
-| `complex_analysis` | 99% | | `pde` | 94% |
-| `fractals_chaos` | 83% | | `probability` | 98% |
+| `complex_analysis` | 99% | | `pde` | 99% |
+| `fractals_chaos` | 100% | | `probability` | 98% |
 | `geometry` | 99% | | `special_functions` | 99% |
 | `graph_theory` | 99% | | `statistics` | 99% |
-| `linalg` | 94% | | `integrators` | 41% |
-| `number_theory` | 97% | | `constants` | 100% |
+| `linalg` | 94% | | `integrators` | 100% |
+| `number_theory` | 98% | | `constants` | 100% |
 
 `visualizers/` modules are smoke-tested only (correct return type/shape,
 or that `anim.save()` succeeds) rather than covered line-by-line, per the
-testing convention in [CLAUDE.md](CLAUDE.md). `integrators` looks low
-only because its bodies are `@njit`-compiled, and coverage cannot trace
-compiled code; every integrator is tested directly, and with the JIT
-disabled the subpackage is fully covered:
-
-```bash
-NUMBA_DISABLE_JIT=1 MPLBACKEND=Agg pytest -q mathematicskit/integrators --cov=mathematicskit.integrators
-```
+testing convention in [CLAUDE.md](CLAUDE.md).
 
 ## Docs
 

{mathematicskit-0.4.0 → mathematicskit-0.5.0}/mathematicskit/__init__.py

@@ -11,7 +11,7 @@ implemented, and CHANGELOG.md for the full roadmap.
 
 # Defined before the subpackage imports: each subpackage re-exports it via
 # ``from mathematicskit import __version__`` while this module is still loading.
-__version__ = "0.4.0"
+__version__ = "0.5.0"
 
 from mathematicskit import (  # noqa: E402
     abstract_algebra,

{mathematicskit-0.4.0 → mathematicskit-0.5.0}/mathematicskit/integrators/__init__.py

@@ -5,8 +5,13 @@ ndarray`` convention throughout, so a single compiled callback can be reused
 across systems with different parameter values without recompiling (see
 :mod:`mathematicskit.integrators.fixed_step`).
 
+* :func:`euler_integrate` -- explicit (forward) Euler, first order: the
+  baseline every other method improves on.
 * :func:`rk4_integrate` -- classical 4th-order Runge-Kutta (not
   energy-preserving).
+* :func:`adams_bashforth_integrate` -- explicit Adams-Bashforth linear
+  multistep methods of orders 1-4 (RK4 start-up), one right-hand-side
+  evaluation per step.
 * :func:`leapfrog_integrate` (alias :func:`velocity_verlet_integrate`) --
   2nd-order symplectic Stormer-Verlet, for separable systems
   ``pos'' = force(pos, t)``.
@@ -26,12 +31,27 @@ across systems with different parameter values without recompiling (see
   collocation (:func:`scipy.integrate.solve_bvp`), returning a
   :class:`BVPResult`.
 
+:func:`stability_function`, :func:`is_absolutely_stable` and
+:func:`adams_bashforth_boundary_locus` describe each explicit and
+implicit method's linear stability region in the ``z = lam * dt`` plane
+(see :mod:`mathematicskit.integrators.stability`).
+
 :mod:`mathematicskit.ode_dynamics` builds its phase portraits, bifurcation
 diagrams, and Poincare sections on top of this shared module rather than
 reimplementing per-domain integrators, exactly as physicskit's
 ``classical/core/integrators.py`` wraps its own shared integrators for
 that subpackage's njit-callback calling convention.
 
+The integrator kernels are compiled per process and deliberately not
+cached to disk (no ``cache=True``). Each one takes the callback itself as
+an argument, so a cache entry is keyed on that callback's dispatcher.
+Numba cannot re-save an index holding keys whose dispatchers belonged to
+an earlier process, so the second script to use a new callback would
+crash with ``ReferenceError: underlying object has vanished``. The
+kernels that take only arrays and scalars (e.g. the ``rhs`` functions in
+:mod:`mathematicskit.ode_dynamics` and :mod:`mathematicskit.pde`) stay
+cached.
+
 :func:`njit` is re-exported here for writing those callbacks: it is
 :func:`numba.njit` when Numba is installed (``pip install
 mathematicskit[fast]``) and a no-op decorator otherwise, with
@@ -43,6 +63,8 @@ from mathematicskit.integrators.adaptive import dopri5_integrate, dopri5_step
 from mathematicskit.integrators.bvp import BVPResult, collocation_bvp
 from mathematicskit.integrators.fixed_step import (
     RHSFunc,
+    euler_integrate,
+    euler_step,
     leapfrog_integrate,
     leapfrog_step,
     rk4_integrate,
@@ -53,13 +75,19 @@ from mathematicskit.integrators.fixed_step import (
     yoshida4_step,
 )
 from mathematicskit.integrators.implicit import implicit_euler_integrate, implicit_euler_step, stiff_integrate
+from mathematicskit.integrators.multistep import ADAMS_BASHFORTH_COEFFICIENTS, adams_bashforth_integrate
+from mathematicskit.integrators.stability import STABILITY_METHODS, adams_bashforth_boundary_locus, is_absolutely_stable, stability_function
 
 __all__ = [
     "HAS_NUMBA",
     "njit",
     "RHSFunc",
+    "euler_step",
+    "euler_integrate",
     "rk4_step",
     "rk4_integrate",
+    "ADAMS_BASHFORTH_COEFFICIENTS",
+    "adams_bashforth_integrate",
     "leapfrog_step",
     "leapfrog_integrate",
     "velocity_verlet_step",
@@ -73,4 +101,8 @@ __all__ = [
     "stiff_integrate",
     "BVPResult",
     "collocation_bvp",
+    "STABILITY_METHODS",
+    "stability_function",
+    "is_absolutely_stable",
+    "adams_bashforth_boundary_locus",
 ]

{mathematicskit-0.4.0 → mathematicskit-0.5.0}/mathematicskit/integrators/adaptive.py

@@ -53,7 +53,7 @@ _E6 = _B6 - _B6S
 _E7 = -_B7S
 
 
-@njit(cache=True)
+@njit
 def dopri5_step(
     rhs: RHSFunc,
     state: NDArray[np.float64],
@@ -97,7 +97,7 @@ def dopri5_step(
     return state_new, error
 
 
-@njit(cache=True)
+@njit
 def dopri5_integrate(
     rhs: RHSFunc,
     state0: NDArray[np.float64],

{mathematicskit-0.4.0 → mathematicskit-0.5.0}/mathematicskit/integrators/fixed_step.py

@@ -27,6 +27,8 @@ from mathematicskit._jit import njit
 
 __all__ = [
     "RHSFunc",
+    "euler_step",
+    "euler_integrate",
     "rk4_step",
     "rk4_integrate",
     "leapfrog_step",
@@ -42,7 +44,95 @@ __all__ = [
 RHSFunc = Callable[[NDArray[np.float64], float, NDArray[np.float64]], NDArray[np.float64]]
 
 
-@njit(cache=True)
+@njit
+def euler_step(
+    rhs: RHSFunc,
+    state: NDArray[np.float64],
+    t: float,
+    dt: float,
+    params: NDArray[np.float64],
+) -> NDArray[np.float64]:
+    """Single explicit (forward) Euler step: ``state + dt * rhs(state, t)``.
+
+    Follows the tangent line for one step (Euler 1768). The local error is
+    :math:`O(dt^2)`, so the global error over a fixed interval is
+    :math:`O(dt)`. For ``y' = lam * y`` one step multiplies ``y`` by
+    :math:`R(z) = 1 + z` with :math:`z = lam \\cdot dt`, so the method is
+    stable only inside the disc :math:`|1 + z| \\le 1` (see
+    :mod:`mathematicskit.integrators.stability`).
+
+    Parameters
+    ----------
+    rhs : callable
+        Numba-jitted right-hand-side function ``rhs(state, t, params) ->
+        ndarray``.
+    state : ndarray of float, shape (dim,)
+        Current state vector.
+    t : float
+        Current time.
+    dt : float
+        Step size.
+    params : ndarray of float
+        Parameter vector passed through to `rhs`.
+
+    Returns
+    -------
+    ndarray of float, shape (dim,)
+        The state advanced by one step of size `dt`.
+    """
+    return state + dt * rhs(state, t, params)
+
+
+@njit
+def euler_integrate(
+    rhs: RHSFunc,
+    state0: NDArray[np.float64],
+    t0: float,
+    dt: float,
+    n_steps: int,
+    params: NDArray[np.float64],
+) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
+    """Integrate ``n_steps`` of explicit Euler starting from ``state0``.
+
+    Parameters
+    ----------
+    rhs : callable
+        Numba-jitted right-hand-side function ``rhs(state, t, params) ->
+        ndarray``.
+    state0 : ndarray of float, shape (dim,)
+        Initial state vector.
+    t0 : float
+        Initial time.
+    dt : float
+        Step size.
+    n_steps : int
+        Number of integration steps.
+    params : ndarray of float
+        Parameter vector passed through to `rhs`.
+
+    Returns
+    -------
+    times : ndarray of float, shape (n_steps + 1,)
+        Time at each step, starting at `t0`.
+    states : ndarray of float, shape (n_steps + 1, dim)
+        State at each step, starting at `state0`.
+    """
+    dim = state0.shape[0]
+    states = np.empty((n_steps + 1, dim))
+    times = np.empty(n_steps + 1)
+    states[0] = state0
+    times[0] = t0
+    state = state0.copy()
+    t = t0
+    for i in range(n_steps):
+        state = euler_step(rhs, state, t, dt, params)
+        t = t0 + (i + 1) * dt
+        states[i + 1] = state
+        times[i + 1] = t
+    return times, states
+
+
+@njit
 def rk4_step(
     rhs: RHSFunc,
     state: NDArray[np.float64],
@@ -78,7 +168,7 @@ def rk4_step(
     return state + (dt / 6.0) * (k1 + 2.0 * k2 + 2.0 * k3 + k4)
 
 
-@njit(cache=True)
+@njit
 def rk4_integrate(
     rhs: RHSFunc,
     state0: NDArray[np.float64],
@@ -127,7 +217,7 @@ def rk4_integrate(
     return times, states
 
 
-@njit(cache=True)
+@njit
 def leapfrog_step(
     force: RHSFunc,
     pos: NDArray[np.float64],
@@ -168,7 +258,7 @@ def leapfrog_step(
     return pos_new, vel_new
 
 
-@njit(cache=True)
+@njit
 def leapfrog_integrate(
     force: RHSFunc,
     pos0: NDArray[np.float64],
@@ -241,7 +331,7 @@ _YOSHIDA_W0 = -_YOSHIDA_CBRT2 / (2.0 - _YOSHIDA_CBRT2)
 _YOSHIDA_W1 = 1.0 / (2.0 - _YOSHIDA_CBRT2)
 
 
-@njit(cache=True)
+@njit
 def yoshida4_step(
     force: RHSFunc,
     pos: NDArray[np.float64],
@@ -292,7 +382,7 @@ def yoshida4_step(
     return pos, vel
 
 
-@njit(cache=True)
+@njit
 def yoshida4_integrate(
     force: RHSFunc,
     pos0: NDArray[np.float64],