soft-float-starter-pack
Software implementation of floating point numbers and operations (by Kimbatt)
libm
A port of MUSL's libm to Rust. (by rust-lang)
soft-float-starter-pack | libm | |
---|---|---|
1 | 8 | |
157 | 498 | |
- | 1.6% | |
0.0 | 5.5 | |
over 1 year ago | 2 days ago | |
C# | Rust | |
MIT License | Apache License 2.0 |
The number of mentions indicates the total number of mentions that we've tracked plus the number of user suggested alternatives.
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
soft-float-starter-pack
Posts with mentions or reviews of soft-float-starter-pack.
We have used some of these posts to build our list of alternatives
and similar projects. The last one was on 2021-02-15.
-
Cross-platform deterministic physics with Unity DOTS physics and soft floats
My code for the soft floats is available here.
libm
Posts with mentions or reviews of libm.
We have used some of these posts to build our list of alternatives
and similar projects. The last one was on 2022-02-08.
-
`libm-0.2.6` dependency fails to build for Mac M1
Yes I took a look at build.rs. There's nothing here that stands out to me. Building the project on my Ubuntu machine works btw.
-
Rust f64::tan() twice as slow as Go math.Tan()
The more interesting code is the "kernel" tangent function https://github.com/rust-lang/libm/blob/master/src/math/k_tan.rs . I don't see any numerical analysis of accuracy in either the Rust lib or the MUSL source lib, but from one of the comments it looks like it's intended to be within 1ULP, which is what I'd expect.
-
Slow performance in Rust compared to Go and C# with math, especially f64::tan()
It's nowhere near complete, but: https://github.com/rust-lang/libm
-
Algorithm to compute Trigonometric functions
Inaccurate fast implementations use polynomial approximation. Accurate implementations use high-powered argument reduction and then polynomial approximation. Everything is polynomial approximation.
-
Porting Rust's std to rustix
It looks like https://github.com/rust-lang/libm/pull/249 may be a fix for this.
-
ELI5: How does calculator know and use pi if even super computers can't know all the digits. Does it use like first 100 digits?
In order to be standards-compliant, computer math libraries need to have a lot more digits of pi than should be strictly necessary. Accurately calculating sine in the upper reaches of double precision floats requires computer to have a table of about 100 digits of pi (or rather pi/2 for technically reasons) and 500 digits of 2/pi - here is an example.
-
Cross-platform deterministic physics with Unity DOTS physics and soft floats
So, fixed-point numbers weren't the solution to the problem either. The next thing I came across was the Rapier physics engine. It promises cross-platform determinism all IEEE 754-2008 compliant platforms. Although it's written in Rust, creating C# bindings was fairly easy, and I could use it in Unity after a few hours. But Rapier is still in early stages of development, which means that (at the time of writing this) it lacked many features, like raycasting, which would have been necessary for my project. Also, it's only deterministic on IEEE 754-2008 compliant platforms. But I couldn't really find any information on which processors support it. Even if I did, I still wanted to have deterministic physics on all platforms, not just on "most of them". But I still wondered does how Rapier achieve cross-platform floating point determinism. Supporting only IEEE 754-2008 compliant platforms is one thing, but the mathematical functions I mentioned above (sqrt, trigonometry, etc.) must also be deterministic. I found out that it uses libm, which implements all of these functions in software. It was primarily designed for embedded systems without FPUs, but it turns out it's also pretty useful for making this part of floating point math deterministic. But after all, the basic mathematical operations of floats are still not deterministic. Unless... How about emulating the behavior of floats in software? It should be possible to write a program that works on the byte representation of a float, doing all operations using integer arithmentic... right?
What are some alternatives?
When comparing soft-float-starter-pack and libm you can also consider the following projects:
unity-deterministic-physics - Cross-platform deterministic physics simulation in Unity, using DOTS physics and soft floats
SoftFloat - An implementation of 32 bit floating point arithmetic in C#
2DFPhysics - 2D fixed-point physics for Unity (WIP).
EntityComponentSystemSamples
compiler-builtins - Porting `compiler-rt` intrinsics to Rust
Incremental - Incremental Deterministic Decimal Number Type in C#
rust - Empowering everyone to build reliable and efficient software.
rustix - Safe Rust bindings to POSIX-ish APIs
clap-rs - A full featured, fast Command Line Argument Parser for Rust
soft-float-starter-pack vs unity-deterministic-physics
libm vs unity-deterministic-physics
soft-float-starter-pack vs SoftFloat
libm vs SoftFloat
soft-float-starter-pack vs 2DFPhysics
libm vs EntityComponentSystemSamples
soft-float-starter-pack vs EntityComponentSystemSamples
libm vs compiler-builtins
soft-float-starter-pack vs Incremental
libm vs rust
libm vs rustix
libm vs clap-rs