heyoka 0.19.0

This new release focuses on cleanups, documentation and maintenance, as most of the development work for this release was focused on the Python bindings (https://github.com/bluescarni/heyoka.py).

The full changelog, as usual, is available here:

https://bluescarni.github.io/heyoka/changelog.html

heyoka 0.18.0

This new version of heyoka comes with a big new feature and several fixes.

Automatic parallelisation 🚀

heyoka 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/tut_parallel_mode.html

Astrodynamics 🪐

• It is now possible to construct (N+1)-body problems - that is, N-body problems expressed in the reference frame of one of the bodies (rather than in an inertial reference frame).
• The Kepler solver now returns NaN in case of invalid input arguments (e.g., non-finite arguments, non-elliptic eccentricity) or if numerical root finding exceeds the maximum number of iterations.

Fixes & clean-ups 🐞

• Several small issues in the implementation of propagate_grid() were identified and fixed.
• Several compilation warnings occurring in debug mode when using recent clang versions were fixed.
• Support for the recently-released LLVM 14.
• heyoka now builds against LLVM 13/14 without deprecation warnings.

The full changelog, as usual, is available here:

https://bluescarni.github.io/heyoka/changelog.html

heyoka 0.17.1

This is a minor release featuring:

• two fixes for test failures on FreeBSD 🐞,
• a change in behaviour for the propagate_*() functions: in presence of a stopping terminal event, the callback is now invoked and the continuous output is updated (whereas previously a stopping terminal event was essentially treated in the same way as an error condition, preventing both the execution of the callback and the update of the continuous output).

The full changelog, as usual, is available here:

https://bluescarni.github.io/heyoka/changelog.html

heyoka 0.17.0

This new version of heyoka comes with a big new feature, several quality-of-life improvements and a few fixes.

Ensemble propagations 🚀

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).

Note that, at this time, ensemble mode is limited to using multithreading for parallelisation.

Quality of life improvements

• Several functions in the batch integration API now also accept scalar time values in input, instead of just vectors. This change improves the usability of batch mode by reducing the amount of typing necessary to interact with batch integrators;
• a function to compute the suggested SIMD size for the CPU in use was added;
• it is now possible to access the internal representation of the integrator's time variable as a double-length float;
• the LLVM version number against which heyoka was built is now exported in the CMake config-file package. This information is intended to be used by packages depending on heyoka to avoid inadvertently linking together different versions of LLVM.

Fixes 🐞

• A couple of build failures were fixed;
• a potential issue arising when certain data structures related to event detection are destroyed in the wrong order has been corrected.

The full changelog, as usual, is available here:

https://bluescarni.github.io/heyoka/changelog.html

heyoka 0.16.0

This is another big release for heyoka, featuring 2 major new features and substantial performance improvements.

Event detection support in batch mode ⏩

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/tut_batch_mode.html#event-detection

Continuous output 📈

Debuting in this release is support for continuous output for the propagate_for/until() functions 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/tut_d_output.html#continuous-output

https://bluescarni.github.io/heyoka/tut_batch_mode.html#dense-continuous-output

This feature has been inspired by a similar feature available in the DifferentialEquations.jl package.

Performance improvements 🚀

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.

Miscellanea ☑️

• Support for LLVM 13.
• Fix potential issue with data aliasing in corner cases.
• Fix wrong counting of integration steps in case of interruption by a terminal event.

The full changelog, as usual, is available here:

https://bluescarni.github.io/heyoka/changelog.html

heyoka 0.15.0

This is one of the biggest releases of heyoka to date, featuring various new capabilities, a major change in the expression system and several fixes.

Reference semantics for funcs

A fundamental change debuting in heyoka 0.15.0 is that function nodes in the expression system now use reference semantics, instead of value semantics. In practice, this means that copying non-trivial expressions does not result any more in a deep copy of the original object, but rather in a new reference to the original object. Deep copies of expressions can be performed via the newly-introduced copy() function.

This change is motivated by various use cases involving large symbolic expressions with a high degree of internal repetition (including, e.g., artificial neural networks), which can now be handled by the expression system orders of magnitude more efficiently (from the point of view of both CPU and memory utilisation).

This is technically a breaking change, although if you just use expressions in the definition of ODEs it is likely that no changes are needed in your code.

New features in the expression system 🖋️

• It is now possible to compute the symbolic derivative of an expression with respect to a parameter.
• Numerical constants can now be defined in a symbolic way. The symbolic π constant is now available in the expression system, using this new framework.
• The two-argument inverse tangent function atan2() has been added to the expression system.

The VSOP2013 solution 🪐

An implementation of the VSOP2013 analytical solution for the motion of the planets of the Solar System has been added to the expression system. This means that it is now possible to formulate differential equations containing the positions/velocities of the planets of the Solar System as functions of time.

Improved support for PPC64 💻

Thanks to the generosity of OSU's Open Source Lab, who provided remote access to a PowerPC workstation, heyoka now features much better support for 64-bit PowerPC processors. In particular, heyoka is now able to take advantage of the hardware-accelerated quadruple-precision arithmetic capabilities of recent PowerPC processors.

Other changes ☑️

• Performance improvements to event detection.
• Various fixes and improvements to the build system.
• Fix a corner-case issue in the implementation of the kepE() function.

Full changelog

As usual, the full changelog is available here:

https://bluescarni.github.io/heyoka/changelog.html

heyoka 0.14.0

This new release of heyoka implements an important improvement in the automatic deduction of the cooldown value for terminal events, which should now be more reliable than before.

The full changelog, as usual, is available here:

https://bluescarni.github.io/heyoka/changelog.html

heyoka 0.12.0

The 0.12.0 release of heyoka features two important additions:

• serialisation support,
• support for 64-bit ARM and PowerPC CPUs.

Serialisation

Serialisation allows to save/load heyoka objects to/from file and to transmit them over the network. A tutorial showcasing this new feature is available here:

https://bluescarni.github.io/heyoka/tut_s11n.html

Please pay attention to the very important CAVEATS highlighted at the beginning of the tutorial!

Support for non-x86 CPUs

This is the first version of heyoka officially supporting 64-bit ARM and PowerPC processors. Builds on these architectures have been added to the continuous integration pipeline, courtesy of Travis and CircleCI.

Note that, on PowerPC, long double is not supported by heyoka at this time (though that might change in the future).

Bugfixes

An issue in the implementation of the move-assignment operator of the llvm_state class was fixed.

heyoka 0.11.0

This is a minor new release which introduces performance optimisations for the creation of large ODE systems and implements symbolic differentiation for the time expression (which allows to compute the variational equations of non-autonomous systems).

As usual, the full changelog is available here:

https://bluescarni.github.io/heyoka/changelog.html

heyoka 0.10.1

This is a bugfix release which solves an issue in the deduction of the number of parameters of an ODE system from the event equations.

No other changes are included. The full changelog, as usual, is available here:

https://bluescarni.github.io/heyoka/changelog.html