Data

Tools

Indexes

Applications

Experiments

Open Source Science

Recent Releases of https://github.com/bluescarni/heyoka.py

https://github.com/bluescarni/heyoka.py - heyoka.py 7.5.1

This is a quick release that fixes an interpreter crash when exceptions are thrown during the construction of an integrator with events.

The full changelog, as usual, is available here:

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

- Python
Published by bluescarni 9 months ago

https://github.com/bluescarni/heyoka.py - heyoka.py 7.5.0

This is a quick release introducing a couple of new important features:

  • an implementation of the Greenwich mean sidereal time (GMST) in the expression system,
  • new frame transformations to/from the TEME frame used by the SGP analytical models.

As usual, the full changelog is available here:

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

- Python
Published by bluescarni 10 months ago

https://github.com/bluescarni/heyoka.py - heyoka.py 7.4.0

- Python
Published by bluescarni 10 months ago

https://github.com/bluescarni/heyoka.py - heyoka.py 7.3.3

This is a quick release fixing the upload of binary wheels to PyPI.

- Python
Published by bluescarni about 1 year ago

https://github.com/bluescarni/heyoka.py - heyoka.py 7.3.2

This is a quick release fixing the upload of binary wheels to PyPI.

- Python
Published by bluescarni about 1 year ago

https://github.com/bluescarni/heyoka.py - heyoka.py 7.3.1

This is a quick release fixing the upload of binary wheels to PyPI.

- Python
Published by bluescarni about 1 year ago

https://github.com/bluescarni/heyoka.py - heyoka.py 7.3.0

Version 7.3.0 marks a significant milestone in the evolution of heyoka.py, taking concrete steps toward becoming a comprehensive tool for spacecraft operations.

This release introduces a suite of new physical models essential for high-precision orbital mechanics and mission planning, including time conversions, reference frame transformations, Earth orientation parameters and space weather modeling. Additionally, heyoka.py now supports the EGM2008 geopotential model and the IAU2000/2006 precession-nutation theory, enhancing its fidelity for orbital dynamics. New classes for managing space weather and Earth orientation data provide streamlined access to operational datasets.

This new release also introduces support for free-threaded Python, with a corresponding pre-compiled binary wheel for free-threaded Python 3.13.

As usual, the full changelog is available here:

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

- Python
Published by bluescarni about 1 year ago

https://github.com/bluescarni/heyoka.py - heyoka.py 7.2.2

This is an incremental release that adds Linux aarch64 (i.e., 64-bit Linux arm) precompiled wheels.

The full changelog, as usual, is available here:

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

- Python
Published by bluescarni over 1 year ago

https://github.com/bluescarni/heyoka.py - heyoka.py 7.2.1

This is a quick bugfix release that works around a thread safety issue in the erfa routines on top of which UTC/TAI conversions are implemented.

As usual, the full changelog is available here:

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

- Python
Published by bluescarni over 1 year ago

https://github.com/bluescarni/heyoka.py - heyoka.py 7.2.0

This new heyoka.py release focuses on clarifying the handling of epochs and dates in the SGP4 propagator. Specifically, Julian dates are now always required to be provided in the UTC scale of time. Internally, epochs and dates are converted to the TAI scale of time in order to ensure accurate propagation even in the presence of leap seconds.

The full changelog, as usual, is available here:

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

- Python
Published by bluescarni over 1 year ago

https://github.com/bluescarni/heyoka.py - heyoka.py 7.0.1

This is a hotfix release that corrects an issue in the unit tests on Python 3.13. Additionally, the documentation is not included any more in the sdist in order to reduce the tarball size and allow upload to PyPI.

As usual, the full changelog is available here:

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

- Python
Published by bluescarni over 1 year ago

https://github.com/bluescarni/heyoka.py - heyoka.py 7.0.0

NOTE: despite the major version bump, there are no API breaking changes.

This is an incremental release which updates the minimum supported Python version to 3.9 and the minimum supported NumPy version to 2 (hence the major version bump).

Other changes include:

  • better tuning for Zen 4 and later CPUs,
  • improved support for non-standard batch sizes (i.e., batch sizes which do not correspond exactly to native SIMD sizes),
  • several improvements and tweaks to the SGP4 propagator,
  • the source distribution is now uploaded to PyPI.

Note also that the parallel compilation feature, added in version 6, has been temporarily disabled due to several LLVM bugs.

As usual, the full changelog is available here:

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

- Python
Published by bluescarni over 1 year ago

https://github.com/bluescarni/heyoka.py - heyoka.py 6.1.2

This is a quick hotfix release that fixes PyPI metadata.

Please see the release notes of version 6.1.0 for a list of changes: https://github.com/bluescarni/heyoka.py/releases/tag/v6.1.0

- Python
Published by bluescarni over 1 year ago

https://github.com/bluescarni/heyoka.py - heyoka.py 6.1.1

This is a quick hotfix release that fixes the uploading of binary wheels to PyPI.

Please see the release notes of version 6.1.0 for a list of changes: https://github.com/bluescarni/heyoka.py/releases/tag/v6.1.0

- Python
Published by bluescarni over 1 year ago

https://github.com/bluescarni/heyoka.py - heyoka.py 6.1.0

This is an incremental release whose main feature is the addition of a proper pyproject.toml file, contributed by @agseaton.

The new pyproject.toml file (which in turn relies on scikit-build-core) provides an alternative way of building heyoka.py which integrates better with modern Python packaging practices :snake: . The new pyproject.toml-based build system is now being used to produce the binary wheels for heyoka.py.

Another noteworthy change is that, beginning from this version, heyoka.py does not open any more the main compiled module with the non-default RTLD_GLOBAL setting. This hack was necessary in order to make the symbols defined in the heyoka C++ library and its dependencies visible to the JIT runtime, but, thanks to changes in the C++ library, it is not needed any more. The net result should be a lower risk of symbol collisions when the heyoka.py binary wheels are used together with other packages from the scientific Python ecosystem.

As usual, the full changelog is available here:

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

- Python
Published by bluescarni over 1 year ago

https://github.com/bluescarni/heyoka.py - heyoka.py 6.0.0

Improved support for mega-kernels :zap:

The main focus of this new heyoka.py release is improved support for very large computational graphs in both Taylor integrators and compiled functions. Specifically:

  • when compact_mode is active, heyoka.py now splits the LLVM IR code in multiple modules rather than keeping it all in a single module - this leads to noticeable improvements in compilation time;
  • the new parjit boolean flag (that can optionally be passed to the constructors of Taylor integrators and compiled functions) can be used to enable parallel compilation in compact_mode - this can lead to dramatically-reduced compilation times on multicore machines;
  • it is now possible to pass the desired LLVM code model to the constructors of Taylor integrators and compiled functions. By default, the small code model is used, but very large computational graphs (which would error out in previous heyoka versions) might require the large model.

[!WARNING] Due to several LLVM issues around parallel JIT compilation discovered during this latest heyoka.py development cycle, the parjit flag is currently off by default on Unix platforms and completely disabled on Windows. Turning on parjit on Unix platforms is considered safe but can very rarely result in a runtime exception being thrown. See the "known issues" page for more details:

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

We expect the parjit feature to become more stable in later LLVM releases, at which point it will be turned on by default.

Improvements to the integrator API :hammer:

  • It is now possible to initialise a Taylor integrator without providing a set of initial conditions - this will result in a zeroed-out initial state vector.
  • The integrator constructor will now error out if a non-empty array of parameter values with the incorrect size is specified. If an empty array of parameter values is passed on construction, the parameter values in the integrator will be zero-inited.

pow() improvements :boom:

Exponentiations with non-numerical exponents are now supported in the right-hand side of ODEs.

As usual, the full changelog is available here:

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

- Python
Published by bluescarni over 1 year ago

https://github.com/bluescarni/heyoka.py - heyoka.py 5.1.0

SGP4 propagation :earth_africa:

heyoka.py 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.py'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.py'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:

https://bluescarni.github.io/heyoka.py/notebooks/sgp4_propagator.html

Logical and relational operators, select() :pencil:

Another new feature in this release is support for logical and relational operators, as well as the select() primitive, in the heyoka.py 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.

manylinux_2_28 :desktop_computer:

The Linux binary wheels of heyoka.py are now built on top of the manylinux_2_28 images, instead of the manylinux2014 images. The manylinux2014 images have reached EOL at the end of June 2024.

The full changelog, as usual, is available here:

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

- Python
Published by bluescarni almost 2 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 5.0.1

This is a quick hotfix release for an issue where heyoka.py would wrongly throw an error on valid code.

Please see the release notes for version 5.0.0 to see what's new in heyoka.py:

https://github.com/bluescarni/heyoka.py/releases/tag/v5.0.0

As usual, the full changelog is available here:

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

- Python
Published by bluescarni almost 2 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 5.0.0

Variational equations :dizzy:

With version 5.0.0, heyoka.py 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.py 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.

Thermosphere models :robot:

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.

For more information, see also the arxiv preprint https://arxiv.org/html/2405.19384v1.

The full changelog, as usual, is available here:

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

- Python
Published by bluescarni almost 2 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 4.0.0

Breaking changes

Version 4 of heyoka.py introduces several backwards-incompatible changes, most of which have been prompted by user feedback. The updated heyoka.py 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.py/breaking_changes.html#bchanges-4-0-0

If you have questions, please do not hesitate to ask.

Parallel compiled functions

The compiled function class cfunc has gained the ability to parallelise batch evaluations via multithreading. The tutorial has been updated accordingly:

https://bluescarni.github.io/heyoka.py/notebooks/compiled_functions.html

Support for Lagrangian and Hamiltonian mechanics

heyoka.py is now able to automatically generate (and solve) the equations of motion from user-supplied Lagrangians and Hamiltonians. Here is 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 list 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.

Performance improvements

The substitution primitive subs() has been substantially sped up. The compilation time of compiled functions has also been improved.

New example/tutorial

A tutorial on gravity gradient stabilisation has been added:

https://bluescarni.github.io/heyoka.py/notebooks/gg_stab.html

The full changelog, as usual, is available here:

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

- Python
Published by bluescarni about 2 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 3.2.0

This new release of heyoka.py comes packed with several new features and enhancements.

New AI/ML examples

Thanks to great work by @Sceki and @darioizzo, two new examples have been added to the documentation. The first one explains how to interface pytorch and heyoka.py:

https://bluescarni.github.io/heyoka.py/notebooks/torchandheyoka.html

The second one presents an innovative, differentiable model for the Earth's atmospheric density implemented via a neural network:

https://bluescarni.github.io/heyoka.py/notebooks/differentiable_atmosphere.html

Support for single-precision computations

In addition to extended and arbitrary precision computations, heyoka.py now supports also single-precision computations via the NumPy float32 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.py 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.py 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.

Miscellanea

  • manylinux wheels for Python 3.12 have been added
  • Fix wrong truncation to double precision in the dtime setter for the scalar integrator

As usual, the full changelog is available here:

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

- Python
Published by bluescarni over 2 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 3.1.0

This new release of heyoka.py 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 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.

Other

  • New example notebook on the continuation of periodic orbits in the CR3BP.
  • New example notebook implementing Lagrange propagation.

Fixes

  • Improve the behaviour of the in-memory cache.
  • Improve the numerical stability of the Kepler solvers.
  • Fix slow performance when creating very large compiled functions.
  • Fix building against Python 3.12

As usual, the full changelog is available here:

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

- Python
Published by bluescarni over 2 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 3.0.0

NOTE: despite the major version bump, there are no public API changes with respect to heyoka.py 2.0.0.

This is a maintenance release which brings heyoka.py in sync with version 3.0.0 of the heyoka C++ library. There are no API changes or new functionality with respect to heyoka.py 3.0.0 (apart from the fact that heyoka.py 3.0.0 inherits bugfixes from version 3.0.0 of the heyoka C++ library).

The full changelog, as usual, is available here:

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

The changelog of the heyoka C++ library is available here:

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

- Python
Published by bluescarni over 2 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 2.0.0

NOTE: the major version number has been bumped from 1 to 2 because heyoka.py now requires version 2.0.0 of the heyoka library. However, there are no public API changes with respect to heyoka.py 1.0.0.

This new release of heyoka.py focuses on several LLVM-related improvements fixes.

In-memory cache

heyoka.py 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.py can now optionally take advantage of the LLVM SLP vectoriser. The vectoriser can be enabled via the boolean keyword argument slp_vectorize (False by default), which can be passed to any heyoka.py 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.py 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 the heyoka library was built with support for the SLEEF library.

New CR3BP model

An implementation of the circular restricted three-body problem has been added to the model submodule. The new model provides the non-dimensional equations of motion and the formula for the Jacobi constant.

As usual, the full changelog is available here:

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

- Python
Published by bluescarni over 2 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 1.0.0

Version 1.0.0 of heyoka.py is here, and it brings several new features and important changes.

Semantic versioning

Starting from this release, heyoka.py adopts the semantic versioning numbering scheme. In particular:

  • the MAJOR version will be increased in case of backwards-incompatible changes in the public API,
  • the MINOR version will be increased in case of backwards-compatible additions to the public API,
  • the PATCH version will be increased in case of backwards-compatible bugfixes.

Note that, due to the lack of API docs at the present time, heyoka.py's public API is somewhat fuzzily defined by the C++ and Python tutorials.

Overhaul of the expression system

The biggest user-facing change in this release is a comprehensive internal overhaul of the expression system, including:

  • the removal of several ad-hoc primitives with somewhat redundant functionality (e.g., square(), sqrt(), sum_sq(), etc.);
  • the implementation of several automated simplifications/normalisations, mostly inspired by the behaviour of SymPy;
  • the re-implementation of sums and products as multivariate functions.

Users are encouraged to read this tutorial in order to understand how to best take advantage of the revamped expression system.

New API to compute high-order derivatives

A new function called diff_tensors() is available to compute efficiently high-order derivative tensors. Please see this tutorial for an introduction to this new feature.

Improvements to step callbacks

Step callbacks can now optionally implement a pre_hook() method that will be invoked once before the first step in a time-limited propagation is performed. This feature can be useful to implement an init/setup phase in the callback before the numerical integration starts. The tutorial has been updated to include this new feature.

Additionally, in multi-threaded ensemble propagations the step callback is now copied for each iteration of the ensemble, rather than being shared among all the iterations. This behaviour should reduce the risk of data races.

New model submodule

A new model submodule has been introduced, which includes functions to generate the dynamics for several commonly-used dynamical models (e.g., pendulum, N-body, etc.). The make_nbody_sys() helper has been replaced by an equivalent function in the model submodule. More models are planned to be added in the near future.

Miscellanea

  • Substitution of generic subexpressions has been implemented;
  • the screen output of expressions is now truncated for very large expressions;
  • several other quality-of-life improvements.

As usual, the full changelog is available here:

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

- Python
Published by bluescarni almost 3 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.21.8

This is a bugfix release that fixes building against NumPy 1.25.

- Python
Published by bluescarni almost 3 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.21.7

This latest release of heyoka.py adds prebuilt pip packages for linux. Additionally, time-dependent functions can now be compiled.

The full changelog, as usual, is available here:

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

- Python
Published by bluescarni over 3 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.21.6

- Python
Published by bluescarni over 3 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.21.5

- Python
Published by bluescarni over 3 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.21.4

- Python
Published by bluescarni over 3 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.21.3

- Python
Published by bluescarni over 3 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.21.2

- Python
Published by bluescarni over 3 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.21.1

- Python
Published by bluescarni over 3 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.21.0

- Python
Published by bluescarni over 3 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.20.0

This new heyoka.py release comes with a big new feature and several small fixes and additions.

Arbitrary-precision computations :heavydivisionsign:

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.

Fixes :lady_beetle:

  • fix build issue with Python 3.11;
  • fix several small issues in the real128 API.

The full changelog, as usual, is available here:

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

- Python
Published by bluescarni over 3 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.19.0

This new version of heyoka.py comes with two big new features and a few fixes.

Extended-precision computations :heavydivisionsign:

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

Compiled functions :rocket:

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

Fixes :bug:

  • heyoka.py now compiles without deprecation warnings against the latest versions of the fmt library

The full changelog, as usual, is available here:

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

- Python
Published by bluescarni over 3 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.18.0

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

Automatic parallelisation :rocket:

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

Astrodynamics :ringed_planet:

  • 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).
  • A fast Kepler solver (supporting both scalar values and NumPy arrays) is now available.

Fixes & clean-ups :lady_beetle:

  • Several small issues in the implementation of propagate_grid() were identified and fixed.
  • heyoka.py now depends on the Intel TBB library.
  • heyoka.py does not depend any more on the spdlog library.

The full changelog, as usual, is available here:

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

- Python
Published by bluescarni about 4 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.17.0

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

Ensemble propagations :rocket:

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

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 full changelog, as usual, is available here:

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

- Python
Published by bluescarni over 4 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.16.0

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

Event detection support in batch mode :fast_forward:

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

Continuous output :chartwithupwards_trend:

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.

Performance improvements :rocket:

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 :ballotboxwith_check:

  • 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.py/changelog.html

- Python
Published by bluescarni over 4 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.15.1

This is a quick bugfix :bug: release that fixes an issue in the conversion of SymPy rationals to the heyoka.py expression system.

The full changelog is available here:

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

- Python
Published by bluescarni over 4 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.15.0

This is one of the biggest releases of heyoka.py 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.py 0.15.0 is that function nodes in the expression system now use reference semantics, instead of value semantics. 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).

New features in the expression system :fountain_pen:

  • 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 :ringed_planet:

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.

A tutorial introducing this new feature is available here:

https://bluescarni.github.io/heyoka.py/notebooks/vsop2013.html

Improved support for PPC64 :computer:

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

Other changes :ballotboxwith_check:

  • 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.py/changelog.html

- Python
Published by bluescarni over 4 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.14.0

This new release of heyoka.py 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.py/changelog.html

- Python
Published by bluescarni almost 5 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.12.0

The 0.12.0 release of heyoka.py features two important additions:

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

Serialisation

Serialisation allows to save/load heyoka.py objects via Python's pickle module. A tutorial showcasing this new feature is available here:

https://bluescarni.github.io/heyoka.py/notebooks/pickling.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.py officially supporting 64-bit ARM processors. ARM builds have been added to the continuous integration pipeline, courtesy of CircleCI.

- Python
Published by bluescarni almost 5 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.11.0

This is a minor release to keep the release number of heyoka.py in sync with the release number of the heyoka C++ library. Apart from a new tutorial notebook and a few doc fixes, there are no functional changes with respect to version 0.10.0.

The full changelog, as usual, is available here:

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

- Python
Published by bluescarni almost 5 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.10.0

The latest version of heyoka.py comes with an important new feature, the ability to convert heyoka.py expressions to/from SymPy expressions. A tutorial showcasing this new feature is available here.

Additionally, this release introduces a change in the API of the callbacks that can (optionally) be passed to the propagate_*() methods. Also, this release features a new pairwise product primitive and various improvements to the automatic simplification capabilities of the expression system.

As usual, the detailed changelog is available here:

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

- Python
Published by bluescarni almost 5 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.9.0

This release includes two new functions in the expression system: the inverse of Kepler's elliptic equation and time polynomials.

Additionally, this release features also performance improvements and various internal cleanups.

The full changelog, as usual, is available here:

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

- Python
Published by bluescarni about 5 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.8.0

This new release of heyoka.py features a couple of breaking changes in the event detection API. The changes are explained in detail here:

https://bluescarni.github.io/heyoka.py/breaking_changes.html#bchanges-0-8-0

The release contains also a couple of new features for the propagate_*() functions. As usual, the full changelog is available here:

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

- Python
Published by bluescarni about 5 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.7.0

This new release of heyoka.py comes with several feature additions and a couple of fixes.

One important improvement is that the time coordinate in the adaptive integrators is now represented internally in double-length format, which greatly increases time accuracy.

As usual, the full changelog is available here:

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

- Python
Published by bluescarni about 5 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.6.1

This is a small incremental release that bumps up the minimum required version of the heyoka C++ library to 0.6.1.

The full changelog, as usual, is available here:

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

- Python
Published by bluescarni about 5 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.6.0

This new version of heyoka.py comes with a big new feature, event detection. Various tutorials exploring this new feature are available:

https://bluescarni.github.io/heyoka.py/advanced_tutorials.html#event-detection

Another important new feature is that propagate_grid() can now be used with the batch integrator.

The full changelog is available here:

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

- Python
Published by bluescarni about 5 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.5.0

This is a minor release that features additions and improvements to the expression system. In particular, the symbolic differentiation capabilities of heyoka's expression system are now available also in Python.

The full changelog, as usual, is available here:

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

- Python
Published by bluescarni over 5 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.4.0

This new release of heyoka.py comes with several new features:

  • support for outputting the Taylor coefficients that were used to perform a single time step,
  • support for dense (continuous) output,
  • efficient propagation over a time grid via dense output,
  • new automatic simplifications in the expression system,
  • a new function powi() for exponentiation with natural exponents.

There is also an important bugfix regarding a division by zero in certain corner cases when using pow() with small natural exponents.

As usual, the full changelog is available here:

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

- Python
Published by bluescarni over 5 years ago

https://github.com/bluescarni/heyoka.py - heyoka.py 0.3.0

This is the initial release of heyoka.py.

- Python
Published by bluescarni over 5 years ago