Validating direct solvers for Newton's gravitational N-body problem, and the systematic comparison between IEEE floating point and Posits
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Physics. The day in general physics: instruments, methods and results across the field.
Kai: We're looking at the paper: "Validating direct solvers for Newton's gravitational N-body problem, and the systematic comparison between IEEE floating point and Posits".
Mira: Here's the gist of the paper. We present a systematic comparison between arbitrary precise arithmetic and integration, IEEE-754 compliant floating point arithmetic (fp16, bfp16, fp32, double precision fp64, and quadruple precision fp128), and two implementations of Posits (type III unum) for solving Newton’s chaotic N-body problem.
Kai: The single most informative sentence about the paper's subject and finding is that "One of the implementations of Posits (Universal) gives precision comparable to fp64 but is slow (by at least an orders of magnitude compared to fp64 after correcting for the more efficient hardware support for the latter)" Experimental Setup and Error Quantification The experimental setup involves designing a series of N-body solvers to integrate Newton’s equations of motion for N point masses in time, starting from initial conditions generated in IEEE-754 double precision The gravitational N-body problem is chaotic for N > 2, and the results are susceptible to small errors To quantify the first variety of errors, researchers measure the deviation of conserved quantities, such as energy and angular momentum The second variety of errors is quantified by measuring the magnification factor (α), which relates to the Lyapunov time scale (tλ) Performance Comparison Across Precision Levels The comparison spans various precisions, including half precision arithmetic (fp16, bfp16) and single precision (fp32), as half precision is deemed insufficiently precise for solving Newton’s equations of motion The 64-bit implementations of fp64 and Posits (Posits) experience difficulty in the tests The Universal implementation of Posits gives precision comparable to fp64 but is slow by at least an orders of magnitude compared to fp64 after correcting for hardware support The CPPPosits implementation has a speed comparable to fp64 but has systematically larger errors by about an order of magnitude compared to fp64 with excesses exceeding two orders of magnitude System Sensitivity and Galilean Invariance The paper tests the Galileo invariancy of numerical representations by testing whether Posits and fp64 have difficulty when integrating a dynamical system in a moving reference frame The results show that CPPPosits, Universal, and fp64 suffer from under Galilean invarincy In the case of the binary D9 orbiting the Galactic central black hole, Posits fail in resolving the orbit of D9 around the black hole The study concludes that Posits may not be the optimal choice for integrating chaotic or stiff ordinary differential equations because of concerns about occasional large rounding error (CPPPosits) Universal produces a narrower range of errors compared to IEEE floating point arithmetic, but the mean number of preserved correct digits is smaller The paper argues that regular IEEE-754 double precision gives acceptable results for most cases, but more precision would be preferable Posits fail to resolve the intricacies of close encounters in self-gravitating systems, while Universal performs considerably more consistent The lack of a formal standard for Posits seems to lead to differences in implementation and therewith in speed The largest errors in direct N-body simulations originate from particles in the central portion of the cluster, whereas particles in the outskirts are less affected by numerical precision Performance Summary The performance comparison shows that fp64 was the fastest, with ∼ 7 · 10−5/η s for 100 N-body time units CPPPosit were ∼ 120 times slower than the same calculations using floating point arithmetic for the 100-particle Plummer model The energy conservation for each of the calculations using CPPPosits and Universal is an order of magnitude worse than for fp64 The most critical comment about Posits is their apparent loss of predictability The implementation of CPPPosits fail to provide reliable errors for calculations over a wide dynamic range Universal performs considerably more consistent Acknowledgments and Software The acknowledgments thank Georgi Gaydadjiev, Lourens Veen, Peter Coveney, Tjarda Boekholt, and Douglas Heggie for their contributions The various precision N-body codes used for this project can be found in https://gitlab.strw.leidenuniv.nl/spz/NBotox Brutus is available on git@gitlab.strw.leidenuniv.
Title and authors: Kai: So this paper is called "Validating direct solvers for Newton's gravitational N-body problem, and the systematic comparison between IEEE floating point and Posits". It sounds like they are really putting these different math tools through their paces.
Mira: Yeah, it’s about testing arbitrary precision arithmetic against standard floating point formats like fp16, fp32, fp64, and even quadruple precision up to fp128. They also include two versions of Posits for this test.
Lev: I hear they are looking at how these solvers perform when solving Newton's chaotic N-body problem. That’s a pretty demanding task because the results are super sensitive to even tiny errors >
Kai: Exactly, and the core idea is to see which one gives you better precision and speed across all these different levels of accuracy. It sets up a systematic comparison against arbitrary precision calculations for an objective evaluation.
Mira: They're not just looking at speed, though; they are quantifying the error in two ways: first by comparing their phase space results to a solution from arbitrary-precision arithmetic, which tells you about round-off and integration errors >
Lev: And the second way is measuring something called lambda t lambda, which relates to the Lyapunov time scale. That’s how fast things diverge in chaotic systems; it helps quantify the sensitivity of the system to those small numerical mistakes >
Kai: So they're essentially creating a benchmark for when you should trust standard floating point versus these other methods for complex simulations like N-body dynamics. It’s about objective performance across different precision levels.
The paper's summary: Mira: The summary boils down to testing how these solvers handle the chaotic nature of Newton's equations of motion for N point masses over time. They use initial conditions generated in IEEE-seven hundred fifty-four double precision as their starting point > <ref:2608.17032#pg1>
Kai: They are comparing things like half precision, fp16 and bfp16, against single precision fp32, but they suggest half precision isn't precise enough for this kind of motion because it leads to relatively large errors in any individual strong encounter >
Lev: And then they move on to the sixty-four-bit implementations of both fp64 and Posits <ref:2608.17032#pg1>. They found that the Universal implementation of Posits gives precision comparable to fp64, but it’s significantly slower, by at least an order of magnitude when you factor in hardware support for floating point numbers >
Mira: That's a key finding because it shows that while you might get similar precision with Posits, the speed penalty is huge compared to what standard hardware can offer for fp64 >
Kai: But they also looked at the CPPPosits implementation and found it systematically has larger errors by about an order of magnitude when compared to fp64, with excesses exceeding two orders of magnitude in some cases >
Lev: So, in short, they're saying that Posits isn't a simple drop-in replacement for floating point because the error characteristics are quite different depending on which implementation you use >
Mira: They conclude that regular IEEE-seven hundred fifty-four double precision gives acceptable results for most cases but suggests that more precision is better if you can get it, while Posits struggle with the intricacies of close encounters in self-gravitating systems > <ref:2608.17032#pg1>
The paper's improvements: Kai: The authors suggest a few ways to improve things. One big suggestion is that improved N-body solvers can actually achieve higher precision than standard floats for the same number of bits when they use Posits >
Lev: That means if you use Posits, you could potentially get more accuracy for the same memory footprint, which is useful when you're constrained by hardware resources >
Mira: And this leads to the idea that we can design AI systems to monitor achieved precision during calculations and apply corrections if they detect an issue >
Kai: So maybe a hybrid approach where an independent evaluation monitors how precise things are getting and applies a correction when needed, that could be really powerful for these chaotic systems >
Lev: It would take some dedicated hardware or very sophisticated software to implement that monitoring layer, which is where the real overhead lands in terms of computational cost >
Mira: I wonder if the benefit from this AI monitoring outweighs the complexity of setting up that kind of correction mechanism for such a demanding problem like Newton's equations >
Conclusion: Kai: So to wrap up, they’re saying that while Posits can offer higher precision than standard floats for the same amount of bits, it’s not the perfect tool for every chaotic N-body simulation because some implementations introduce large rounding errors >
Mira: They noted that the Universal implementation of Posits produces a narrower range of errors compared to IEEE floating point arithmetic, but even then, the mean number of preserved correct digits is smaller than what you get from double precision >
Lev: They also pointed out that Posits fail to resolve the intricacies of close encounters in self-gravitating systems, which is a critical issue when you have particles interacting very strongly >
Kai: The implication for us is that regular IEEE-seven hundred fifty-four double precision is often good enough for most scenarios, but if you need better accuracy, we probably should stick with that unless we can figure out how to make Posits more consistent > <ref:2608.17032#pg1>
Mira: And they noted that the lack of a formal standard for Posits seems to cause differences in implementation and thus differences in speed across different versions >
Lev: For me, what sticks is that the most critical comment about Posits is their apparent loss of predictability when compared to fp64, which is something you really have to consider when dealing with chaotic systems >
Kai: So the paper "Validating direct solvers for Newton's gravitational N-body problem, and the systematic comparison between IEEE floating point and Posits" shows us that precision isn't just about having more bits; it’s about how consistently those extra bits are used in practice.
Leiden Observatory University of Leiden
physics.comp-ph, astro-ph.IM, cs.PL, nlin.CD
Submitted: 2026-08-17
Updated: 2026-11-16
Comments: submitted to Computer Physics Communication (processed referees comments)
Code: https://github.com/unipi-dii-compressedarith/cppposit
License: http://creativecommons.org/licenses/by/4.0/
Importance score: 62/100
The gist: We present a systematic comparison between arbitrary precise arithmetic and integration, IEEE-754 compliant floating point arithmetic (fp16, bfp16, fp32, double precision fp64…
Key concepts
- IEEE-754 Floating Point Arithmetic
- This is the standard way computers handle numbers with finite precision, such as fp64 (double precision). It's fast and widely supported but can introduce small errors when solving complex, chaotic systems like the N-body problem.
- Posits (Type III Unum)
- Posits is an arbitrary precise arithmetic system used to solve differential equations. It aims to offer higher accuracy than standard floating-point methods by controlling the precision of calculations, which is useful for difficult problems.
- Magnification Factor ($\alpha$)
- This factor measures how much small errors in the simulation grow over time, relating directly to the Lyapunov time scale ($t\lambda$). A larger magnification factor indicates that the system's trajectory becomes unpredictable faster.
Terminology
Summary
We present a systematic comparison between arbitrary precise arithmetic and integration, IEEE-754 compliant floating point arithmetic (fp16, bfp16, fp32, double precision fp64, and quadruple precision fp128), and two implementations of Posits (type III unum) for solving Newton’s chaotic N-body problem. p. 0 Validating direct solvers for Newton’s gravitational N-body problem, and the systematic
comparison between IEEE floating point and Posits. Simon Portegies Zwart1
aLeiden Observatory University of Leiden Einsteinweg 55 2333 CC Leiden The Netherlands
Abstract
We present a systematic comparison between arbitrary precise arithmetic and integration, IEEE-754 compliant floating point arithmetic (fp16, bfp16, fp32, double precision fp64, and quadruple precision fp128), and two implementations of Posits (type III unum)
for solving Newton’s chaotic N-body problem.Where the paper says it
The single most informative sentence about the paper's subject and finding is that "One of the implementations of Posits (Universal) gives precision comparable to fp64 but is slow (by at least an orders of magnitude compared to fp64 after correcting for the more efficient hardware support for the latter)"
Experimental Setup and Error Quantification
The experimental setup involves designing a series of N-body solvers to integrate Newton’s equations of motion for N point masses in time, starting from initial conditions generated in IEEE-754 double precision The gravitational N-body problem is chaotic for N > 2, and the results are susceptible to small errors To quantify the first variety of errors, researchers measure the deviation of conserved quantities, such as energy and angular momentum The second variety of errors is quantified by measuring the magnification factor (α), which relates to the Lyapunov time scale (tλ)
Performance Comparison Across Precision Levels
The comparison spans various precisions, including half precision arithmetic (fp16, bfp16) and single precision (fp32), as half precision is deemed insufficiently precise for solving Newton’s equations of motion The 64-bit implementations of fp64 and Posits (Posits) experience difficulty in the tests The Universal implementation of Posits gives precision comparable to fp64 but is slow by at least an orders of magnitude compared to fp64 after correcting for hardware support The CPPPosits implementation has a speed comparable to fp64 but has systematically larger errors by about an order of magnitude compared to fp64 with excesses exceeding two orders of magnitude
System Sensitivity and Galilean Invariance
The paper tests the Galileo invariancy of numerical representations by testing whether Posits and fp64 have difficulty when integrating a dynamical system in a moving reference frame The results show that CPPPosits, Universal, and fp64 suffer from under Galilean invarincy In the case of the binary D9 orbiting the Galactic central black hole, Posits fail in resolving the orbit of D9 around the black hole
Conclusion on Solver Suitability
The study concludes that Posits may not be the optimal choice for integrating chaotic or stiff ordinary differential equations because of concerns about occasional large rounding error (CPPPosits) Universal produces a narrower range of errors compared to IEEE floating point arithmetic, but the mean number of preserved correct digits is smaller The paper argues that regular IEEE-754 double precision gives acceptable results for most cases, but more precision would be preferable Posits fail to resolve the intricacies of close encounters in self-gravitating systems, while Universal performs considerably more consistent The lack of a formal standard for Posits seems to lead to differences in implementation and therewith in speed The largest errors in direct N-body simulations originate from particles in the central portion of the cluster, whereas particles in the outskirts are less affected by numerical precision
Performance Summary
The performance comparison shows that fp64 was the fastest, with ∼ 7 · 10−5/η s for 100 N-body time units CPPPosit were ∼ 120 times slower than the same calculations using floating point arithmetic for the 100-particle Plummer model The energy conservation for each of the calculations using CPPPosits and Universal is an order of magnitude worse than for fp64 The most critical comment about Posits is their apparent loss of predictability The implementation of CPPPosits fail to provide reliable errors for calculations over a wide dynamic range Universal performs considerably more consistent
Acknowledgments and Software
The acknowledgments thank Georgi Gaydadjiev, Lourens Veen, Peter Coveney, Tjarda Boekholt, and Douglas Heggie for their contributions The various precision N-body codes used for this project can be found in https://gitlab.strw.leidenuniv. p. 2 We call this
code NBotox, and it is publicly available at https://gitlab. leidenuniv. We call this
code NBotox, and it is publicly available at https://gitlab. leidenuniv. It employs dynamic
time steps which are calculated per step using the smallest freefall time scale at the current realization of the particles, and
subsequently multiplied by a tuning parameter η. We call this
code NBotox, and it is publicly available at https://gitlab.Where the paper says it
Where the paper says it
Where the paper says it
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Improved N-body solvers can achieve higher precision than floats for same number of bits by using Posits, which
achieve higher precision than floats for the same number of bits.
This allows for more accurate integration in chaotic systems like Newton’s equations of motion. -
The system can perform better at resolving close encounters due to improved handling of rounding errors, as
Universal performs considerably more consistent
than CPPPosits when dealing with close encounters in self-gravitating systems. -
AI systems can be designed to monitor achieved precision during calculations and apply corrections, potentially using a hybrid approach where
an independent evaluation monitors the achieved precision, applying a correction in the case of a problem.
Abstract
We present a systematic comparison between arbitrary precise arithmetic and integration, IEEE-754 compliant floating point arithmetic (fp16, bfp16, fp32, double precision fp64, and quadruple precision fp128), and two implementations of Posits (type III unum) for solving Newton's chaotic N-body problem. Each implementation is benchmarked with arbitrary precise calculations to objectively evaluate their performance in precision as well as speed. We rely on hardware and compiler implementations for fp64, and software implementations for arbitrary-precision arithmetic and Posits. Half precision arithmetic (fp16, bfp16, and Posits <16,1>) are insufficiently precise for solving Newton's equations of motion. Single precision (fp32, and Posits <32,2>) could be used for statistical ensemble calculations, but lead to relatively large errors in any individual strong encounter. All 64-bit implementations fp64 as well as Posits (Posits <64,3>) experience difficulty in our tests. One of the implementations of Posits (Universal) gives precision comparable to fp64 but is slow (by at least an orders of magnitude compared to fp64 after correcting for the more efficient hardware support for the latter). The other (CPPPosits) has a speed comparable to fp64 but has systematically larger errors (by about an order of magnitude compared to fp64 with excesses exceeding two orders of magnitude). As a consequence, this implementation leads to a systematic drift in the result space and has difficulty resolving close encounters. Posits and fp64 have difficulty when integrating a dynamical system in a moving reference frame; testing Galileo invariancy. In their current implementation, Posits do not seem to be the ideal alternative for fp64 when integrating chaotic or stiff ordinary differential equations, such as Newton's equations of motion.
Sources
- Evaluation of POSIT Arithmetic with Accelerators
- Numerical verification of the microscopic time reversibility of Newton's equations of motion: Fighting exponential divergence
- On the Reliability of N-body Simulations
- The formation of periodic three-body orbits for Newtonian systems
- Binary--single-star scattering VII. Hard Binary Exchange Cross Sections for Arbitrary Mass Ratios: Numerical Results and Semi-Analytic Fits
- A binary system in the S cluster close to the supermassive black hole Sagittarius A*
Related papers
- Gradient-Based Inverse Design of Free-Energy Landscapes with Diffusion Models
- Mixture of Polyconvex Neural Potentials for Parametric Hyperelasticity: Towards Foundation Material Models
- Development and large-scale benchmarks of a protein--ligand absolute binding free energy toolkit
- Spin disorder competing with positional symmetry breaking governs the metal-insulator behavior in oxide paramagnets
- Investigation of the Asymptotic Properties of Active Impedance in Large Finite Array Antennas
- Automatic generation of exchange-correlation response kernels