Changelog

7.0.0 (unreleased)

New

• Add a function to determine if a GPE is deep-space (#463).

Changes

• Enable the use of 512-bit vectors on Zen>=4 cpus (#464).

• Improve support for non-standard SIMD sizes in vector functions (#464).

• The parallel compilation feature has been temporarily disabled due to several LLVM bugs (#463).

• Several small tweaks to the behaviour of the SGP4 propagator: non-normalised double-length Julian dates are now accepted, deep-space GPEs do not result in exceptions any more, and performance improvements for the replace_sat_data() function (#463).

• BREAKING: heyoka now requires mp++ version 2 (#462). This is a breaking change.

6.1.0 (2024-10-10)

Fix

• Fix symbols not found by the JIT runtime when heyoka is dlopen()-ed with RTLD_LOCAL (#460).

• Workaround for a clang 17 issue that would result in runtime exceptions during (de)serialisation (#458).

6.0.0 (2024-09-21)

New

• Support LLVM 19 (#455).

• Non-number exponents for the pow() function are now supported in Taylor integrators (#454).

• It is now possible to initialise a Taylor integrator with an empty initial state vector. This will result in zero-initialization of the state vector (#449).

• Implement parallel compilation for Taylor integrators and compiled functions (#446, #444, #441).

• Add the possibility of specifying the LLVM code model used for JIT compilation (#440).

• Enable support for fmt 11 (#440).

Changes

• BREAKING: the array of parameter values passed to the constructor of a Taylor integrator must now either be empty (in which case the parameter values will be zero-inited), or have the correct size (#451). This is a breaking change.

• BREAKING: the minimum required LLVM version is now 15 (#444). This is a breaking change.

Fix

• Fix build system warnings when using recent versions of CMake and Boost (#440).

• Fix compilation on FreeBSD (#439).

5.1.0 (2024-07-21)

New

• Add a fully differentiable implementation of the SGP4 analytical propagator (#433).

• Add the select() primitive to the expression system (#432).

• Add relational and logical operators to the expression system (#432).

Changes

• Reduce the maximum number of iterations in the Kepler solvers and do not log if the iteration limit is reached (#434).

Fix

• Fix compilation on PPC64 (#428).

• Relax several tolerances in order to fix test failures reported on FreeBSD (#428).

5.0.0 (2024-06-13)

New

• Add thermonets: neural, differentiable, high-performance models for the Earth’s thermosphere density (#425).

• Add support for variational ODE systems and Taylor map computation (#422).

• Introduce the ability to represent unknown functions and their derivatives in the expression system (#416).

• Add a vectorised implementation for diff() (#411).

• Add mutable ranges getters for the state and pars data of the adaptive integrators (#409).

• Support LLVM 18 (#408).

Changes

• Speedups in the computation of symbolic derivatives (#414).

• Several automatic simplifications and normalisations in the expression system have been removed as they caused drastic slowdowns in symbolic operations when working with large and highly recursive computational graphs (#412).

• Remove the (undocumented) taylor_add_jet() function and rework the unit test code to use taylor_adaptive instead (#409).

Fix

• Fix test failures on OSX arm64 (#409).

4.0.3 (2024-04-04)

Fix

• Workaround compilation failures in the unit tests when using GCC 13 (#409).

• Fix compilation on FreeBSD (#407).

4.0.2 (2024-03-03)

Fix

• Fix compilation on MinGW (#404).

4.0.1 (2024-03-02)

Fix

• Fix compilation on PowerPC (#401).

4.0.0 (2024-03-02)

New

• heyoka is now available in the spack package manager.

• New tutorial on compiled functions (#396).

• New cfunc class to facilitate the creation and evaluation of compiled functions, supporting automatic multithreaded parallelisation (#396).

• It is now possible to index into the tensors of derivatives using indices vectors in sparse format (#389).

• Add support for Lagrangian and Hamiltonian mechanics (#381, #379).

• It is now possible to pass a range of step callbacks to the propagate_*() functions. The individual callbacks will be automatically composed into a callback set (#376).

• New angle_reducer step callback to automatically reduce angular state variables to the \(\left[0, 2\pi\right)\) range (#376).

• New callback module containing ready-made step and event callbacks (#376).

Changes

• Speedups for the subs() primitive (#394).

• BREAKING: the make_vars() function now returns a single expression (rather than an array of expressions) if a single argument is passed in input (#386). This is a breaking change.

• BREAKING: the signature of callbacks for terminal events has been simplified (#385). This is a breaking change.

• BREAKING: the way in which the propagate_*() functions interact with step callbacks has changed (#376). This is a breaking change.

• BREAKING: the propagate_grid() functions of the adaptive integrators now require the first element of the time grid to be equal to the current integrator time (#373). This is a breaking change.

• Move the declarations of all keyword arguments into the kw.hpp header (#372).

• The call operators of the event callbacks are not const any more (#369).

• BREAKING: the minimum supported LLVM version is now 13 (#369). This is a breaking change.

• BREAKING: heyoka now requires C++20 (#369). This is a breaking change.

• BREAKING: heyoka now requires fmt>=9 (#369). This is a breaking change.

• BREAKING: heyoka now requires mp++ 1.x (#369). This is a breaking change.

3.2.0 (2023-11-29)

New

• Add step callback set classes to compose step callbacks (#366).

• Add support for single-precision computations (#363).

• Add model implementing the ELP2000 analytical lunar theory (#362).

Changes

• When the fast_math mode is active, the SIMD-vectorised mathematical functions now use low-precision implementations. This can lead to substantial performance increases in batch mode (#367).

• Initialising a step callback or a callable from an empty function object (e.g., a null pointer, an empty std::function, etc.) now results in an empty object (#366).

• Improve performance when creating symbolic expressions for large sums and products (#362).

3.1.0 (2023-11-13)

New

• Implement (leaky) ReLU and its derivative in the expression system (#357, #356).

• Add feed-forward neural network model (#355).

• Implement the eccentric longitude \(F\) in the expression system (#352).

• Implement the delta eccentric anomaly \(\Delta E\) in the expression system (#352). Taylor derivatives are not implemented yet.

Changes

• Substantial speedups in the computation of first-order derivatives with respect to many variables/parameters (#360, #358).

• Substantial performance improvements in the computation of derivative tensors of large expressions with a high degree of internal redundancy (#354).

Fix

• Fix global constants in an LLVM module being generated in unordered fashion when compact mode is active. This would result in two logically-identical modules being considered different by the in-memory cache (#359).

• Fix compiler warning when building without SLEEF support (#356).

• Improve the numerical stability of the VSOP2013 model (#353).

• Improve the numerical stability of the Kepler solver (#352).

3.0.0 (2023-10-07)

Fix

• Prevent accidental leaking in the public headers of serialisation implementation details (#350).

• Fix wrong version compatibility setting in the CMake config-file package (#350).

• Work around test failure on ARM + LLVM 17 (#350).

• Fix orbital elements singularity when using the VSOP2013 theory at low precision (#348).

2.0.0 (2023-09-22)

New

• Support LLVM 17 (#346).

• Add model for the circular restricted three-body problem (#345).

• heyoka can now automatically vectorise scalar calls to floating-point math functions (#342).

• The LLVM SLP vectorizer can now be enabled (#341). This feature is opt-in due to the fact that enabling it can considerably increase JIT compilation times.

• Implement an in-memory cache for llvm_state. The cache is used to avoid re-optimising and re-compiling LLVM code which has already been optimised and compiled during the program execution (#340).

• It is now possible to get the LLVM bitcode of an llvm_state (#339).

Changes

• BREAKING: the minimum supported LLVM version is now 11 (#342). This is a breaking change.

• The optimisation level for an llvm_state is now clamped within the [0, 3] range (#340).

• The LLVM bitcode is now used internally (instead of the textual representation of the IR) when copying and serialising an llvm_state (#339).

• The optimisation pass in an llvm_state is now automatically called during compilation (#339).

Fix

• Fix compilation in C++20 mode (#340).

• Fix the object file of an llvm_state not being preserved during copy and deserialisation (#339).

• Fix LLVM module name not being preserved during copy and deserialisation of llvm_state (#339).

• Fix broken link in the docs.

1.0.0 (2023-08-10)

New

• The step callbacks can now optionally implement a pre_hook() member function that will be called before the first step is taken by a propagate_*() function (#334).

• The heyoka library now passes all clang-tidy checks (#315).

• Introduce several vectorised overloads in the expression API. These vectorised overloads allow to perform the same operation on a list of expressions more efficiently than performing the same operation repeatedly on individual expressions (#312).

• The expression class is now immutable (#312).

• New API to compute high-order derivatives (#309).

• The state variables and right-hand side of a system of ODEs are now available as read-only properties in the integrator classes (#305).

• Support LLVM 16.

• New model module containing ready-made dynamical models (#302, #295).

• Implement substitution of generic subexpressions (#301).

• Add a function to fetch the list of parameters in an expression (#301).

• The screen output of expressions is now truncated for very large expressions (#299).

Changes

• The step callbacks are now copied in ensemble propagations rather than being shared among threads. The aim of this change is to reduce the likelihood of data races (#334).

• Comprehensive overhaul of the expression system, including: enhanced automatic simplification capabilities for sums, products and powers, removal of several specialised primitives (such as square(), neg(), sum_sq(), etc.), re-implementation of division and subtraction as special cases of product and sum, and more (#332, #331, #330, #329, #328, #327, #326, #325, #324, #323, #322).

• Constant folding is now implemented for all functions in the expression system (#321).

• Moved-from expressions and numbers are now guaranteed to be in the default-constructed state (#319).

• The expression code has been reorganised into multiple files (#317).

• Performance improvements in compact mode for Taylor integrators and compiled functions (#303).

• Update Catch to version 2.13.10 (#301).

• The get_n_nodes() function now returns 0 instead of overflowing (#301).

• heyoka now requires Boost >= 1.69 (#301).

• Performance improvements for several primitives in the expression API (#300).

• Improve hashing performance for large expressions by caching the hashes of repeated subexpressions (#299).

• The unstrided version of compiled functions is now forcibly inlined, which leads to improved codegen and better performance (#299).

• BREAKING: the make_nbody_sys() helper has been replaced by an equivalent function in the new model module (#295). This is a breaking change.

Fix

• Work around a likely LLVM bug on ARM (#310).

• Fix compilation on OSX when mixing recent libcxx versions with old Boost versions (#308).

• Do not mix inline member functions with explicit class template instantiations. This should fix linking issues on Windows when mixing MSVC and clang-cl (#298).

0.21.0 (2023-02-16)

New

• Compiled functions now support time-dependent expressions (#294).

• The heyoka ABI is now properly versioned and tagged (#290).

0.20.1 (2023-01-05)

Changes

• Mark as visible a couple of internal functions which had been marked as hidden by mistake (#286).

0.20.0 (2022-12-17)

New

• Add option in the build system to hide the exported LLVM symbols, when linking statically (#283).

• Add option to force the use of AVX-512 registers (#280).

• Implement support for arbitrary-precision computations (#278, #276).

• Support LLVM 15 (#274).

Changes

• heyoka now depends on CMake >= 3.18 when building from source (#283).

Fix

• Avoid accidental indirect inclusion of libquadmath’s header file (#279).

• Prevent callbacks from changing the time coordinate of the integrator. This was never supported and could lead to crashes and/or hangs in the propagate_*() functions (#278).

0.19.0 (2022-09-18)

New

• Add a short tutorial on extended-precision computations (#270).

• The numerical integrator classes now support class template argument deduction (#267).

• Add the capability to compile multivariate vector functions at runtime (#261).

Changes

• heyoka now builds against recent versions of the fmt library without deprecation warnings (#266).

Fix

• Fix compilation against recent LLVM 14.x releases on Windows (#268).

0.18.0 (2022-05-11)

New

• Add a timekeeping accuracy benchmark (#254).

• Add a function to build (N+1)-body problems (#251).

• Support LLVM 14 (#247).

• Implement parallel mode for the automatic parallelisation of an individual integration step (#237).

Changes

• The Kepler solver now returns NaN in case of invalid input arguments or if the max number of iterations is exceeded (#252).

• heyoka now builds against LLVM 13/14 without deprecation warnings (#242).

• In case of an early interruption, the propagate_grid() function will now process all available grid points before the interruption time before exiting (#235).

• The propagate_grid() callbacks are now invoked also if the integration is interrupted by a stopping terminal event (#235).

Fix

• Fix several warnings related to variable shadowing when compiling in debug mode (#257).

• Fix a potential accuracy issue when setting the time coordinate in double-length format (#246).

• Fix an issue in the propagate_grid() functions that could lead to invalid results in certain corner cases (#234).

0.17.1 (2022-02-13)

Changes

• The propagate_for/until() callbacks are now invoked also if the integration is interrupted by a stopping terminal event (#231).

Fix

• Fix two test failures on FreeBSD (#231).

0.17.0 (2022-01-20)

New

• The LLVM version number against which heyoka was built is now exported in the CMake config-file package (#225).

• It is now possible to access the adaptive integrators’ time values as double-length floats (#225).

• Add support for ensemble propagations (#221).

• Several functions in the batch integration API now also accept scalar time values in input, instead of just vectors. The scalar values are automatically splatted into vectors of the appropriate size (#221).

• Add a function to compute the suggested SIMD size for the CPU in use (#220).

Changes

• Avoid unnecessary copies of the propagate_*() callbacks (#222).

Fix

• Fix compilation in debug mode when using recent versions of fmt (#226).

• Fix potential issue arising when certain data structures related to event detection are destroyed in the wrong order (#226).

• Fix build failures in the benchmark suite (#220).

0.16.0 (2021-11-20)

New

• BREAKING: add support for continuous output to the propagate_for/until() functions (#216). This is a breaking change.

• Event detection is now available also in batch mode (#214).

• Add a sum of squares primitive (#209).

• Add new benchmarks and benchmark results to the documentation (#204).

• Support LLVM 13 (#201).

Changes

• If propagate_grid() exits early in batch mode, the missing values are now set to NaN instead of zero (#215).

• Internal refactoring of the event detection code (#213).

• During event detection, improve the performance of the fast exclusion check via JIT compilation (#212).

• Various internal simplifications in the implementation of Taylor derivatives (#208).

• Performance optimisations for ODE systems containing large summations (#203).

• Performance optimisations in the construction of Taylor integrators (#203).

• BREAKING: the pairwise_sum() function has been replaced by a new function called sum() with similar semantics (#203). This is a breaking change.

Fix

• Fix various corner-case issues in the integrator classes related to data aliasing (#217).

• Fix incorrect counting of the number of steps when the integration is interrupted by a terminal event (#216).

0.15.0 (2021-09-28)

New

• Implement derivatives with respect to the parameters (#196).

• Implement additional automatic simplifications in the expression system (#195).

• Add a way to define symbolic constants in the expression system, and implement \(\pi\) on top of it (#192).

• Add a function to compute the size of an expression (#189).

• Quadruple precision is now correctly supported on PPC64 (#188).

• Add an implementation of the VSOP2013 analytical solution for the motion of the planets of the Solar System, usable in the definition of differential equations (#186, #183, #180).

• Add the two-argument inverse tangent function atan2() to the expression system (#182).

• Implement additional automatic simplifications for sin/cos (#180).

Changes

• Implement a fast exclusion check for event detection which improves performance when no event triggers in a timestep (#198).

• BREAKING: the function class now uses reference semantics. This means that copy operations on non-trivial expressions now result in shallow copies, not deep copies. This is a breaking change (#192).

• heyoka now depends on the TBB library (#186).

Fix

• Don’t force the use of static MSVC runtime when compiling heyoka as a static library (#198).

• Fix compilation as a static library (#195).

• Various fixes to the PPC64 support (#188, #187).

• Fix an issue in kepE() arising from an automatic simplification that would lead to an invalid decomposition for zero eccentricity (#185).

0.14.0 (2021-08-03)

New

• The tolerance value is now stored in the integrator objects (#175).

Changes

• Improve the heuristic for the automatic deduction of the cooldown value for terminal events (#178).

Fix

• Ensure that code generation in compact mode is platform-agnostic and deterministic across executions (#176).

0.12.0 (2021-07-21)

New

• Add support for 64-bit PowerPC processors (#171).

• Add support for 64-bit ARM processors (#167).

• Implement serialisation for the main classes via Boost.Serialization (#163).

Fix

• Fix a bug in the move assignment operator of llvm_state (#163).

0.11.0 (2021-07-06)

New

• The time expression now supports symbolic differentiation (#160).

Changes

• Various performance optimisations for the creation of large ODE systems (#152).

0.10.1 (2021-07-02)

Fix

• Parameters in event equations are now correctly counted when inferring the total number of parameters in an ODE system (#154).

0.10.0 (2021-06-09)

New

• The callback that can be passed to the propagate_*() functions can now be used to stop the integration (#149).

• Add a pairwise product primitive (#147).

Changes

• BREAKING: a breaking change in the propagate_*() callback API (#149).

• Implement additional automatic simplifications in the expression system (#148).

• Division by zero in the expression system now raises an error (#148).

0.9.0 (2021-05-25)

New

• Add time polynomials to the expression system (#144).

• Add the inverse of Kepler’s elliptic equation to the expression system (#138).

• Add an LLVM-based vectorised solver for Kepler’s equation (#136).

• Add an LLVM while loop function (#135).

Changes

• Performance improvements for event detection in the linear and quadratic cases (#145).

• Several functions used for event detection are now compiled just-in-time, rather than being implemented in C++ (#142).

• Cleanup unused and undocumented functions (#134).

• Small performance optimisations (#133).

• Remove the binary_operator node type in the expression system and implement binary arithmetic using the func node type instead (#132). This is an internal change that does not affect the integrators’ API.

0.8.0 (2021-04-28)

New

• The propagate_for/until() functions now support writing the Taylor coefficients at the end of each timestep (#131).

Changes

• BREAKING: various breaking changes in the event detection API (#131).

• Improvements to the stream operator of taylor_outcome (#131).

Fix

• Don’t set the multiroot mr flag to true if a terminal event has a cooldown of zero (#131).

0.7.0 (2021-04-21)

New

• Support LLVM 12 (#128).

• The propagate_*() functions now accept an optional max_delta_t argument to limit the size of a timestep, and an optional callback argument that will be invoked at the end of each timestep (#127).

• The time coordinate in the Taylor integrator classes is now represented internally in double-length format. This change greatly reduces the error in long-term integrations of non-autonomous systems and improves the time accuracy of the predicted state (#126).

• update_d_output() can now be called with a relative (rather than absolute) time argument (#126).

Changes

• Performance improvements for the event detection system (#129).

• BREAKING: the time coordinates in batch integrators cannot be directly modified any more, and the new set_time() function must be used instead (#126).

Fix

• Fix an issue in the automatic deduction of the cooldown time for terminal events (#126).

0.6.1 (2021-04-08)

Changes

• The event equations are now taken into account in the determination of the adaptive timestep (#124).

Fix

• Fix an initialisation order issue in the event detection code (#124).

• Fix an assertion misfiring in the event detection function (#123).

0.6.0 (2021-04-06)

New

• Implement propagate_grid() for the batch integrator (#119).

• Start tracking code coverage (#115).

• Initial version of the event detection system (#107).

• Add a tutorial chapter for batch mode (#106).

• Add a couple of utilities to detect the presence of the time function in an expression (#105).

• Provide the ability to compute the jet of derivatives of arbitrary functions of the state variables (#104).

• Speed-up the deep copy of just-in-time-compiled objects such as llvm_state and taylor_adaptive (#102).

Changes

• BREAKING: the propagate_grid() function now requires monotonically-ordered grid points (#114).

• Change the screen output format for taylor_outcome (#106).

Fix

• In the batch integrator class, the outcomes in the result vectors are now initialised to taylor_outcome::success instead of meaningless values (#102).

0.5.0 (2021-02-25)

New

• Implement various missing symbolic derivatives (#101, #100).

• Implement additional automatic simplifications in the expression system (#100).

• Implement extract() for the func class, in order to retrieve a pointer to the type-erased inner object (#100).

0.4.0 (2021-02-20)

New

• Introduce a dedicated negation operator in the expression system (#99).

• Implement various new automatic simplifications in the expression system, and introduce powi() as an alternative exponentiation function for natural exponents (#98).

• Implement propagation over a time grid (#95).

• Implement support for dense output (#92).

• Add the ability to output the Taylor coefficients when invoking the single-step functions in the integrator classes (#91).

Fix

• Avoid division by zero in certain corner cases when using pow() with small natural exponents (#98).

0.3.0 (2021-02-11)

New

• Implement the error function (#89).

• Implement the standard logistic function (#87).

• Implement the basic hyperbolic functions and their inverse counterparts (#84).

• Implement the inverse trigonometric functions (#81).

• The stream operator of functions can now be customised more extensively (#78).

• Add explicit support for non-autonomous systems (#77).

• heyoka now has a logo (#73).

Changes

• Small optimisations in the automatic differentiation formulae (#83).

• Improve common subexpression simplification in presence of constants of different types (#82).

• Update copyright dates (#79).

• Avoid using a temporary file when extracting the object code of a module (#79).

Fix

• Ensure that pow(x ,0) always simplifies to 1, rather than producing an expression with null exponent (#82).

• Fix build issue with older Boost versions (#80).

• Various build system and doc fixes/improvements (#88, #86, #85, #83, #82, #76, #74).

0.2.0 (2021-01-13)

New

• Extend the Taylor decomposition machinery to work on more general classes of functions, and add tan() (#71).

• Implement support for runtime parameters (#68).

• Initial tutorials and various documentation additions (#63).

• Add a stream operator for the taylor_outcome enum (#63).

Changes

• heyoka now depends publicly on the Boost headers (#68).

Fix

• Fix potential name mangling issues in compact mode (#68).

0.1.0 (2020-12-18)

Initial release.