Changelog

Changelog#

7.0.0 (unreleased)#

New#

  • Upload the source distribution to PyPI (#203).

Changes#

  • heyoka.py now requires version 7.0.0 of the heyoka C++ library (#206).

  • BREAKING: heyoka.py now requires Python >= 3.9 (#206). This is a breaking change.

  • BREAKING: heyoka.py now requires NumPy >= 2 (#206). This is a breaking change.

6.1.2 (2024-10-10)#

Fix#

  • Fix PyPI metadata.

6.1.1 (2024-10-10)#

Fix#

  • Fix upload of binary wheels.

6.1.0 (2024-10-10)#

New#

  • Add a proper pyproject.toml file and use it to produce the binary wheels (#195).

Fix#

  • Do not open the heyoka.py compiled module with RTLD_GLOBAL (#197).

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

6.0.0 (2024-09-21)#

New#

  • Add wheels for Python 3.13 (#193).

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

  • It is now possible to initialise a scalar Taylor integrator with an empty initial state vector, or a batch integrator with a 2D state vector whose first dimension is zero. This will result in zero-initialization of the state vector (#189).

  • Implement parallel compilation for Taylor integrators and compiled functions (#188).

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

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 (#189). This is a breaking change.

  • heyoka.py now requires version 6.0.0 of the heyoka C++ library (#188).

Fix#

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

5.1.0 (2024-07-23)#

New#

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

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

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

  • Add tutorial on Taylor map inversion (#182).

  • Add tutorial on solving inversion problems with the variational equations (#181).

Changes#

  • The minimum supported SymPy version is now 1.13.0 (#183).

  • The binary wheels are now built on top of manylinux_2_28 (#183).

  • heyoka.py now requires version 5.1.0 of the heyoka C++ library (#183).

Fix#

  • Fix test failures when using recent SymPy versions (#183).

5.0.1 (2024-06-14)#

Fix#

  • Fix an input size check that would wrongly throw on valid code (#179).

5.0.0 (2024-06-13)#

New#

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

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

  • Add a vectorised implementation of diff() (#173).

Changes#

  • 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 (#174).

  • BREAKING: as a consequence of the removal of most automatic simplifications, several now-obsolete functions have also been removed (#174). These are breaking changes.

  • heyoka.py now requires version 5.0.0 of the heyoka C++ library (#173).

4.0.0 (2024-03-03)#

New#

  • New convenience hessian() method to fetch the Hessian from a dtens object (#171).

  • Compiled functions now support multithreaded parallelisation for batched evaluations (#168).

  • Add new example on gravity-gradient stabilisation (#159).

  • Add support for Lagrangian and Hamiltonian mechanics (#156).

  • It is now possible to pass a list of step callbacks to the propagate_*() functions (#155).

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

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

Changes#

  • BREAKING: the function to construct compiled functions has been renamed from make_cfunc() to cfunc() (#168). This is a breaking change.

  • BREAKING: compiled functions now require contiguous arrays as input/output arguments. The compiled functions API is also now more restrictive with respect to on-the-fly type conversions (#168). These are breaking changes.

  • BREAKING: it is now mandatory to supply a list of differentiation arguments to diff_tensors() (#164). This is a breaking change.

  • Improve performance when creating compiled functions (#162).

  • BREAKING: compiled functions now require the list of input variables to be always supplied by the user (#162). This is a breaking change.

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

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

  • BREAKING: the propagate_*() functions now return the (optional) step callback that can be passed in input (#155). This is a breaking change.

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

  • The binary wheels are now built on top of manylinux2014 (#153).

  • heyoka.py now requires C++20 when building from source (#153).

  • heyoka.py now requires version 4.0.0 of the heyoka C++ library (#153).

3.2.0 (2023-11-29)#

New#

  • New example on a differentiable atmosphere model via neural networks (#151).

  • New example on interfacing pytorch and heyoka.py (#151).

  • Add wheels for Python 3.12 (#150).

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

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

Changes#

  • heyoka.py now requires version 3.2.0 of the heyoka C++ library (#149).

Fix#

  • Fix wrong truncation to double precision in the dtime setter for the scalar integrator (#150).

3.1.0 (2023-11-13)#

New#

  • New example notebooks on neural ODEs (#143, #142).

  • Add a model for feed-forward neural networks (#142).

  • Implement (leaky) ReLU and its derivative in the expression system (#141).

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

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

  • Implement convenience properties to fetch the gradient/Jacobian from a dtens object (#140).

  • New example notebook implementing Lagrange propagation (#140).

  • New example notebook on the continuation of periodic orbits in the CR3BP (#97).

Changes#

  • heyoka.py now requires version 3.1.0 of the heyoka C++ library (#140).

Fix#

  • Fix slow performance when creating very large compiled functions (#144).

  • Fix building against Python 3.12 (#139).

3.0.0 (2023-10-07)#

Changes#

  • heyoka.py now requires version 3.0.0 of the heyoka C++ library (#137).

2.0.0 (2023-09-22)#

New#

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

  • The LLVM SLP vectorizer can now be enabled (#134). 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 (#134).

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

1.0.0 (2023-08-11)#

New#

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

  • 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 (#127).

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

  • Implement substitution of generic subexpressions (#127).

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

  • Several additions to the compiled functions API: compiled functions can now be pickled/unpickled, and they expose several information as read-only properties (e.g., list of variables, outputs, etc.) (#120).

  • Expressions now support hashing (#120).

  • New model submodule containing ready-made dynamical models (#119).

Changes#

  • BREAKING: the VSOP2013 functions have been moved from the main module to the new model submodule (#130). This is a breaking change.

  • The custom NumPy memory manager that prevents memory leaks with real arrays is now disabled by default (#129).

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

  • 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 (#127).

  • heyoka.py now requires at least version 1.0.0 of the heyoka C++ library (#127).

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

0.21.8 (2023-07-03)#

Fix#

  • Fix building against NumPy 1.25 (#125).

0.21.7 (2023-02-16)#

New#

  • Add support for installation via pip on Linux (#115).

  • Time-dependent functions can now be compiled (#113).

Changes#

  • heyoka.py now requires at least version 0.21.0 of the heyoka C++ library (#113).

0.20.0 (2022-12-18)#

New#

  • Implement arbitrary-precision computations (#108).

  • Implement the isnan() and isinf() NumPy ufuncs for real128 (#108).

  • Several JIT-related settings can now be tweaked via keyword arguments (#107).

Changes#

  • heyoka.py now requires CMake >= 3.18 when building from source (#109).

  • heyoka.py now requires at least version 0.20.0 of the heyoka C++ library (#107).

Fix#

  • Fix the real128 NumPy comparison operator to be consistent with float with respect to NaN values (#108).

  • Prevent the real128 constructor from being called with keyword arguments (#108).

  • Fix a build issue with Python 3.11 (#107).

0.19.0 (2022-09-19)#

New#

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

  • The way quadruple-precision computations are supported via real128 has been completely overhauled: real128 is now exposed as a NumPy-enabled Python type, meaning that real128 can now be used in exactly the same way as float and np.longdouble in the heyoka.py API (#99, #98). This is a breaking change.

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

Changes#

  • BREAKING: heyoka.py is now more strict with respect to type conversions. See the breaking changes section for more details.

  • heyoka.py now compiles without deprecation warnings against the latest fmt versions (#98).

  • New version requirements: heyoka>=0.19, CMake>=3.16, pybind11>=2.10 (#98, #96).

0.18.0 (2022-05-11)#

New#

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

  • Expose numerical solvers for Kepler’s elliptic equation (#91).

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

Changes#

  • heyoka.py does not depend on the spdlog library any more (#89).

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

  • heyoka.py now requires at least version 0.18.0 of the heyoka C++ library (#88).

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

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

Fix#

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

0.17.0 (2022-01-25)#

New#

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

  • Add support for ensemble propagations (#85).

  • 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 (#85).

  • Copy operations on the main heyoka.py classes now preserve dynamic attributes (#85).

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

Changes#

  • heyoka.py now requires at least version 0.17.0 of the heyoka C++ library (#84).

Fix#

  • Fix build failures when using recent versions of fmt (#86).

0.16.0 (2021-11-20)#

New#

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

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

  • Attributes can now be dynamically added to the main heyoka.py classes (#78).

  • Add a tutorial on the computation of event sensitivity (#77).

Changes#

  • heyoka.py now requires at least version 0.16.0 of the heyoka C++ library (#75).

0.15.1 (2021-10-10)#

Fix#

  • Fix conversion from SymPy rationals.

0.15.0 (2021-09-28)#

New#

  • Add a tutorial on the simulation of tides (#70).

  • The conversion of expressions from/to SymPy now takes advantage of reference semantics, which leads to large performance improvements when dealing with expressions with a high degree of internal repetition (#70).

  • Add the possibility to customise the behaviour of the from_sympy() function (#70).

  • Add \(\pi\) as a symbolic constant to the expression system (#70).

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

  • Add an example on the computation of definite integrals (#68).

  • 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 (#67). An example describing this new feature is available in the documentation.

  • Add support for the two-argument inverse tangent function atan2() in the expression system (#64).

Changes#

  • heyoka.py now requires at least version 0.15.0 of the heyoka C++ library (#64).

Fix#

  • Test fixes on PPC64 (#69).

0.14.0 (2021-08-03)#

New#

  • Add a new example on the numerical detection of integrals of motion (#59).

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

Changes#

  • heyoka.py now requires at least version 0.14.0 of the heyoka C++ library (#58).

0.12.0 (2021-07-23)#

New#

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

  • Pickling support has been added to all classes (#53).

  • Event properties can now be accessed after construction (#53).

Changes#

  • heyoka.py now depends on the Boost C++ libraries (#53).

  • heyoka.py now requires at least version 0.12.0 of the heyoka C++ library (#53).

0.11.0 (2021-07-06)#

New#

  • New tutorial on transit timing variations (#50).

Changes#

  • heyoka.py now requires at least version 0.11.0 of the heyoka C++ library (#50).

0.10.0 (2021-06-09)#

New#

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

  • New tutorial on SymPy interoperability (#47).

  • Add a pairwise product primitive (#46).

  • heyoka.py expressions can now be converted to/from SymPy expressions (#46).

Changes#

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

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

  • heyoka.py now requires at least version 0.10.0 of the heyoka C++ library (#46).

0.9.0 (2021-05-25)#

New#

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

  • New tutorial on Mercury’s relativistic precession (#42).

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

  • New tutorial on planetary embryos (#39).

  • Initial exposition of the llvm_state class (#39).

Changes#

  • heyoka.py now requires at least version 0.9.0 of the heyoka C++ library (#41).

0.8.0 (2021-04-28)#

New#

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

Changes#

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

  • heyoka.py now requires at least version 0.8.0 of the heyoka C++ library (#37).

0.7.0 (2021-04-22)#

New#

  • 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 (#34).

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

Changes#

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

  • heyoka.py now requires at least version 0.7.0 of the heyoka C++ library (#34).

0.6.1 (2021-04-08)#

New#

  • Add the wavy ramp tutorial (#32).

Changes#

  • heyoka.py now requires at least version 0.6.1 of the heyoka C++ library (#32).

0.6.0 (2021-04-06)#

New#

  • Add a tutorial about Brouwer’s law (#31).

  • Add a tutorial about batch mode (#30).

  • Add tutorials about gravitational billiards (#29, #28).

  • Expose propagation over a time grid for the batch integrator (#29).

  • Add a tutorial about the computation of Poincaré sections (#27).

  • Add a tutorial on optimal control (#24).

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

  • Expose low-level functions to compute the jet of derivatives for an ODE system (#21).

Changes#

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

  • heyoka.py now depends on the spdlog library (#23).

  • heyoka.py now requires at least version 0.6.0 of the heyoka C++ library (#21).

Fix#

  • Properly restore the original mpmath precision after importing heyoka.py (#21).

0.5.0 (2021-02-25)#

New#

  • Expose symbolic differentiation.

  • Add a new tutorial (restricted three-body problem).

Changes#

  • The interface of the integrator in batch mode has changed to work with arrays in which the batch size has its own dimension, instead of being flattened out (#20).

  • heyoka.py now depends on the {fmt} library (#20).

  • heyoka.py now requires at least version 0.5.0 of the heyoka C++ library (#20).

0.4.0 (2021-02-20)#

New#

  • Expose the new powi() function from heyoka 0.4.0 (#18).

  • Add support for propagate_grid() (#17).

  • Add support for dense output and for storing the Taylor coefficients at the end of a timestep (#11).

  • Various doc additions (#15, #14, #13, #12, #11).

Changes#

  • heyoka.py now requires at least version 0.4.0 of the heyoka C++ library.

0.3.0 (2021-02-13)#

  • This is the initial public release of heyoka.py