Python library for ODE integration via Taylor's method and LLVM
This new heyoka.py release comes with a big new feature and several small fixes and additions.
Taylor integrators shine in high-accuracy applications, and now, with heyoka.py, you can get as accurate as you want!
In addition to double and extended-precision computations, heyoka.py now also supports computations in arbitrary precision. In other words, you can perform numerical integrations with an arbitrarily high accuracy, limited in principle only by the available memory.
Arbitrary-precision computations require the heyoka C++ library to be built with support for the mp++ multiprecision library (see the heyoka installation instructions for more details). A tutorial illustrating how to set up numerical integrations in arbitrary precision is available in the documentation.
real128
API.The full changelog, as usual, is available here:
This new version of heyoka.py comes with two big new features and a few fixes.
Extended-precision computations are now fully supported with an API identical to double-precision computations. A tutorial explaining this new feature is available here:
https://bluescarni.github.io/heyoka.py/notebooks/ext_precision.html
Note that, as a consequence of this new feature, heyoka.py is now more strict than it used to be with respect to type conversions, and this could result in TypeError
exceptions being raised in user code after upgrading. Please see the "Breaking Changes" section in the documentation for more details and solutions:
https://bluescarni.github.io/heyoka.py/breaking_changes.html#bchanges-0-19-0
It is now possible to compile just-in-time functions defined via the heyoka.py expression system. Compiled functions provide fast function evaluation capabilities for scalar and vector arguments. A tutorial describing this new feature is available here:
https://bluescarni.github.io/heyoka.py/notebooks/compiled_functions.html
The full changelog, as usual, is available here:
This new version of heyoka.py comes with a big new feature and several fixes.
heyoka.py is now capable of automatically performing multithreaded fine-grained parallelisation within an individual integration step. Parallel mode is easily enabled, and it can lead to substantial speed-ups, especially for large ODE systems and/or extended precision computations.
A tutorial exploring this new feature is available here:
https://bluescarni.github.io/heyoka.py/notebooks/parallel_mode.html
propagate_grid()
were identified and fixed.The full changelog, as usual, is available here:
This new version of heyoka.py comes with a big new feature, several quality-of-life improvements and a few fixes.
The big new feature is support for ensemble propagations. In ensemble mode, multiple distinct instances of the same ODE system are integrated in parallel, typically using different sets of initial conditions and/or runtime parameters. Monte Carlo simulations and parameter searches are two typical examples of tasks in which ensemble mode is particularly useful.
The combination of ensemble mode with batch integrators can lead to substantial speedups (e.g., a floating-point throughput increase of 23x was observed on a modern desktop computer using 8 threads of execution, see here).
The full changelog, as usual, is available here:
This is another big release for heyoka.py, featuring 2 major new features and substantial performance improvements.
Event detection is now available in the batch mode Taylor integrator. As a result, the batch mode integrator has now feature parity with the scalar mode integrator.
The batch mode event detection API is very similar to scalar mode. A tutorial describing the new feature is available here:
https://bluescarni.github.io/heyoka.py/notebooks/Batch%20mode%20overview.html#event-detection
Debuting in this release is support for continuous output for the propagate_for/until()
methods of the scalar and batch integrators.
Continuous output allows to compute the value of the solution of the ODE system at any time within the integration time interval covered by propagate_for/until()
. Tutorials are available here:
https://bluescarni.github.io/heyoka.py/notebooks/Dense%20output.html#continuous-output
https://bluescarni.github.io/heyoka.py/notebooks/Batch%20mode%20overview.html#continuous-output
This feature has been inspired by a similar feature available in the DifferentialEquations.jl package.
As a result of various micro-optimisations, performance for large ODE systems in compact mode has improved by up to 15%.
Additionally, fast event exclusion checking is now implemented as a JIT-compiled function, which leads to a ~30% reduction in the event detection overhead.
The full changelog, as usual, is available here: