Releases: bluescarni/heyoka
heyoka 5.1.0
SGP4 propagation 🌍
heyoka 5.1.0 adds an implementation of SGP4, a widely-used analytical propagator for Earth-orbiting objects.
SGP4 uses two-line elements sets (TLEs) (available from websites such as CelesTrak and Space-Track) to predict the future or past states of Earth-orbiting objects via a simplified perturbation model. The positional accuracy of SGP4 is in the order of kilometres for propagations up to a few days from the TLE reference epoch.
heyoka's SGP4 implementation is fully differentiable up to arbitrary order, thus enabling applications such as state covariance propagation, state transition matrix computation, gradient-based optimisation, orbit determination, etc.
SGP4 is available either as a low-level function that that produces the analytical formulae of SGP4 in heyoka's expression system, or a as a fast high-level propagator class accelerated via multithreaded parallelisation and SIMD vectorisation, providing state-of-the-art propagation performance. For more details, see the tutorial in the documentation of the Python bindings:
https://bluescarni.github.io/heyoka.py/notebooks/sgp4_propagator.html
Logical and relational operators, select() 📝
Another new feature in this release is support for logical and relational operators, as well as the select() primitive, in the heyoka expression system.
Relational operators allow to perform comparisons (such as "equal to", "less than", "greater than", etc.) during the evaluation of an expression (e.g., during a numerical integration), yielding a numerical value of 1 (true) or 0 (false). Logical operators allow to combine comparisons via logical AND/OR.
The select() primitive can be used to select one of two expressions based on the result of a comparison, thus providing a primitive form of if/then/else branching in the expression system. Note however that select() will always evaluate both the true and false branches, and thus it is unsuitable for complicated flow control.
The full changelog, as usual, is available here:
heyoka 5.0.0
Variational equations 💫
With version 5.0.0, heyoka takes another big leap forward with built-in support for the variational equations - that is, the ability to compute not only the solution of an ODE system, but also its partial derivatives with respect to the initial conditions and/or parameters of the system.
The variational equations, which are automatically formulated by heyoka at any order via a process of efficient symbolic differentiation, enable a host of new applications, such as the solution of inversion problems (e.g., orbit determination), uncertainty propagation, Taylor maps and jet transport, the computation of chaos indicators, training of neural networks in NeuralODEs, etc.
A tutorial describing this new feature is available in the Python bindings.
Thermosphere models 🤖
Another big addition in this release is thermoNETs - a set of novel models for the calculation of the Earth's atmospheric density. These models, which have been recently unveiled at the ISSFD2024 conference, can be used to set up accurate and high-performance simulations of the LEO dynamical environment, accounting for the influence of air drag during orbital propagation. A tutorial describing this new feature is available in the Python bindings.
For more information, see also the arxiv preprint https://arxiv.org/html/2405.19384v1.
Support for LLVM 18
heyoka 5.0.0 adds support for the recently-released version 18 of LLVM.
The full changelog, as usual, is available here:
heyoka 4.0.3
This is a quick release that fixes a couple of build issues, one on FreeBSD and the other affecting the unit tests when building with GCC 13.
NOTE: heyoka 4.x introduces several breaking changes with respect to the 3.x series. Please see the following link for a list of breaking changes and explanations on how to adapt your code to the new API:
https://bluescarni.github.io/heyoka/breaking_changes.html#bchanges-4-0-0
heyoka 4.0.2
This is a quick release that fixes a build issue on MinGW.
NOTE: heyoka 4.x introduces several breaking changes with respect to the 3.x series. Please see the following link for a list of breaking changes and explanations on how to adapt your code to the new API:
https://bluescarni.github.io/heyoka/breaking_changes.html#bchanges-4-0-0
heyoka 4.0.1
This is a quick release that fixes a build issue on PPC64.
NOTE: heyoka 4.x introduces several breaking changes with respect to the 3.x series. Please see the following link for a list of breaking changes and explanations on how to adapt your code to the new API:
https://bluescarni.github.io/heyoka/breaking_changes.html#bchanges-4-0-0
heyoka 4.0.0
Breaking changes
Version 4 of heyoka introduces several backwards-incompatible changes, most of which have been prompted by user feedback. The updated heyoka API should be more streamlined, easier to use and more difficult to misuse.
The detailed list of breaking changes is available at the following page, along with instructions on how to update your code for the API modifications:
https://bluescarni.github.io/heyoka/breaking_changes.html#bchanges-4-0-0
If you have questions, please do not hesitate to ask.
New compiled functions class
A new class that facilitates the creation and use of compiled functions, called cfunc, has been introduced. This class has been available for a while in the Python bindings, and it now makes its official debut in the C++ API. A tutorial illustrating the use of this class is available here:
https://bluescarni.github.io/heyoka/tut_cfunc.html#tut-cfunc
Support for Lagrangian and Hamiltonian mechanics
heyoka is now able to automatically generate (and solve) the equations of motion from user-supplied Lagrangians and Hamiltonians. The Python bindings provide a tutorial illustrating this new feature:
https://bluescarni.github.io/heyoka.py/notebooks/lagrangian.html#lagham-tut
Enhancements to the step callback API
It is now possible to pass a range of step callbacks as an optional argument to the propagate_*() functions. The callbacks will be automatically composed into a callback set and they will be executed at the end of each integration step.
spack availability
Thanks to work by @agseaton, heyoka is now available in the spack package manager. See the updated installation instructions:
https://bluescarni.github.io/heyoka/install.html#spack
Performance improvements
The substitution primitive subs() has been substantially sped up.
The full changelog, as usual, is available here:
heyoka 3.2.0
This new release of heyoka comes packed with several new features and enhancements.
Support for single-precision computations
In addition to extended and arbitrary precision computations, heyoka now supports also single-precision computations via the float type. Single-precision computations can lead to substantial performance benefits, especially in batch mode and/or low-accuracy applications. See the single-precision tutorial for a usage example.
ELP2000 model
heyoka now includes an implementation of the ELP2000 lunar theory. It is thus now possible to formulate systems of differential equations with the time-dependent geocentric lunar position appearing in the right-hand side. See the tutorial for an introduction.
Low-precision vector math
When the fast_math option is active, heyoka now employs lower-precision vector implementations of elementary functions, which can lead to substantial speedups in low-accuracy applications. The speedup is particularly visible when using single precision in AI and ML applications.
As usual, the full changelog is available here:
heyoka 3.1.0
This new release of heyoka comes packed with several new features and enhancements.
Neural networks
It is now possible to create feed-forward neural networks in the expression system, and use them in the definition of ODEs. See the machine learning section in the documentation of the Python bindings for more information and examples.
Complementary to the introduction of neural networks is the addition of the (leaky) ReLU and its derivative to the expression system.
New anomalies
The eccentric longitude F and the delta eccentric anomaly DE have been added to the expression system. These transcendental functions are used in celestial mechanics and astrodynamics to implement Lagrangian propagation and in the definition of equinoctial orbital elements.
Thanks to the introduction of the eccentric longitude F, the analytical ephemeris VSOP2013 should now be more numerically stable for orbits with low eccentricity/inclination.
Performance improvements
Several operations involving the manipulation and differentiation of large symbolic expressions are now substantially faster, often by more than an order of magnitude.
Fixes
- Improve the behaviour of the in-memory cache by ensuring that global constants are always defined in a deterministic order in an LLVM module.
- Improve the numerical stability of the Kepler solvers.
- Fix compiler warning when building without SLEEF support.
As usual, the full changelog is available here:
heyoka 3.0.0
NOTE: despite the major version bump, there are no public API changes with respect to heyoka 2.0.0.
This is a maintenance release which fixes a few issue identified in heyoka 2.0.0. Because one of the issues involves wrong version compatibility settings in the CMake config-file package, the major version number has been precautionarily bumped from 2 to 3. However, there are no public API changes with respect to heyoka 2.0.0.
Another issue fixed in this release involves orbital elements singularities when using the VSOP2013 planetary theory at low precisions. The current fix is a temporary workaround, but the VSOP2013 planetary theory can still suffer from numerical instabilities at low eccentricities/inclinations. A better solution is in the works and it will be implemented in an upcoming heyoka version.
Finally, the conda-forge packages for LLVM 11-12 have been dropped in order to limit the size of the build matrix. The LLVM versions supported by heyoka on conda-forge are now 13 to 16.
The full changelog, as usual, is available here:
heyoka 2.0.0
NOTE: the major version number has been bumped from 1 to 2 because support for LLVM 10 has been dropped. However, there are no public API changes with respect to heyoka 1.0.0.
This new release of heyoka focuses on several LLVM-related improvements and fixes.
In-memory cache
heyoka now features an in-memory cache which avoids re-optimisation and re-compilation of code that was already optimised and compiled during program execution. See this tutorial for a detailed explanation and a couple of examples where this new feature leads to noticeable speedups.
Support for the SLP vectoriser
heyoka can now optionally take advantage of the LLVM SLP vectoriser. The vectoriser can be enabled via the boolean keyword argument kw::slp_vectorize (false by default), which can be passed to any heyoka function/class that uses JIT compilation (e.g., the Taylor adaptive integrators).
Although the SLP vectoriser can lead to noticeable speedups in the performance of JIT-compiled code, it is disabled by default because it can considerably increase the cost of JIT compilation.
Automatic vectorisation of math functions
On recent LLVM versions, heyoka has gained the ability to automatically vectorise scalar calls to math functions. This includes not only math functions implemented as LLVM builtins (e.g., sqrt, sin/cos, etc.), but also external math functions from the C++ math library.
This feature is automatically enabled on recent LLVM versions when SLP vectorisation is turned on and if heyoka was built with support for the SLEEF library.
LLVM 17 in, LLVM 10 out
This release drops support for LLVM 10 and enables support for the freshly-released LLVM 17.
New CR3BP model
An implementation of the circular restricted three-body problem has been added to the models module. The new model provides the non-dimensional equations of motion and the formula for the Jacobi constant.
Initial work on API docs
Initial work has started on detailed API docs. The WIP API reference is available here:
https://bluescarni.github.io/heyoka/api_reference.html
Fixes
- A build issue in C++20 mode has been resolved.
As usual, the full changelog is available here: