Bernie
I came across a clever method for approximate float comparison which exploits their binary representation:
bool almost_equal(float a, float b) {
uint32_t abits = to_bits(a);
uint32_t bbits = to_bits(b);
return abits - bbits < 4;
}
Where 4 is the tolerance in "units in the last place".
to_bits() isn't a simple bit_cast. It also does some magic with the sign bit. But for now let's only consider positive floats...
Bernie
The question on my mind was: does this give the correct distance even around the boundary of an exponent bump?
And yes: mantissa and exponent are arranged in such a way that adding 1 to the binary form always yields the next float:
>>> import struct
>>> to_float = lambda i: unpack(">f", i.to_bytes(4))[0]
>>> to_float(0x3FFFFFFF)
1.9999998807907104
>>> to_float(0x40000000)
2.0
>>> to_float(0x40000001)
2.000000238418579
Bernie
Of course this also works with double and long double.
My production version of almost_equals() is templated using C++20 concepts and the nicer "auto" syntax:
bool almost_equals(std::floating_point auto a, std::floating_point auto b) {
auto abits = to_bits(a);
auto bbits = to_bits(a);
return distance(abits, bibits) < 4;
}
Bernie
For more information, consult your local encyclopedia:
https://en.wikipedia.org/wiki/Single-precision_floating-point_format
Maryam
@codewiz
The distance function only looks at the last bits?
If it looks at the first bits then we're distancing the base.
Bernie
@Maryam It compares all 32 bits of the floats (there's no masking), but it allows the difference to be up to 4 ULPs = 2 least significant bits.
Bernie
@zelphirkaltstahl It works with standard IEEE 754 floats, yes.
The problem with doing (a - b) is that you might get 1000.0 or you might get 0.001. Depending on the magnitude of a and b, both might represent an expected rounding error in the least significant bits of a float.
A codebase I'm working on had arbitrary epsilon constants: 1e-6 for floats and 5e-15 for doubles. Such absolute thresholds are only reasonable for values in a narrow range (for example 0.1..10.0).
Zelphir Kaltstahl
@codewiz Does this consider IEEE 754 floating point format? How is it better than substracting the the floats from each other? Or in which cases?
Bobinas P4G is a social network. It runs on GNU social, version 2.0.1-beta0, available under the GNU Affero General Public License.
All Bobinas P4G content and data are available under the Creative Commons Attribution 3.0 license.