dbbaa959c8
Following discussions in PR #16666, this commit updates the float formatting code to improve the `repr` reversibility, i.e. the percentage of valid floating point numbers that do parse back to the same number when formatted by `repr` (in CPython it's 100%). This new code offers a choice of 3 float conversion methods, depending on the desired tradeoff between code size and conversion precision: - BASIC method is the smallest code footprint - APPROX method uses an iterative method to approximate the exact representation, which is a bit slower but but does not have a big impact on code size. It provides `repr` reversibility on >99.8% of the cases in double precision, and on >98.5% in single precision (except with REPR_C, where reversibility is 100% as the last two bits are not taken into account). - EXACT method uses higher-precision floats during conversion, which provides perfect results but has a higher impact on code size. It is faster than APPROX method, and faster than the CPython equivalent implementation. It is however not available on all compilers when using FLOAT_IMPL_DOUBLE. Here is the table comparing the impact of the three conversion methods on code footprint on PYBV10 (using single-precision floats) and reversibility rate for both single-precision and double-precision floats. The table includes current situation as a baseline for the comparison: PYBV10 REPR_C FLOAT DOUBLE current = 364688 12.9% 27.6% 37.9% basic = 364812 85.6% 60.5% 85.7% approx = 365080 100.0% 98.5% 99.8% exact = 366408 100.0% 100.0% 100.0% Signed-off-by: Yoctopuce dev <dev@yoctopuce.com>
53 lines
2.2 KiB
Python
53 lines
2.2 KiB
Python
# Test that integers format to exact values.
|
|
|
|
for b in [13, 123, 457, 23456]:
|
|
for r in range(1, 10):
|
|
e_fmt = "{:." + str(r) + "e}"
|
|
f_fmt = "{:." + str(r) + "f}"
|
|
g_fmt = "{:." + str(r) + "g}"
|
|
for e in range(0, 5):
|
|
f = b * (10**e)
|
|
title = str(b) + " x 10^" + str(e)
|
|
print(title, "with format", e_fmt, "gives", e_fmt.format(f))
|
|
print(title, "with format", f_fmt, "gives", f_fmt.format(f))
|
|
print(title, "with format", g_fmt, "gives", g_fmt.format(f))
|
|
|
|
# The tests below check border cases involving all mantissa bits.
|
|
# In case of REPR_C, where the mantissa is missing two bits, the
|
|
# the string representation for such numbers might not always be exactly
|
|
# the same but nevertheless be correct, so we must allow a few exceptions.
|
|
is_REPR_C = float("1.0000001") == float("1.0")
|
|
|
|
# 16777215 is 2^24 - 1, the largest integer that can be completely held
|
|
# in a float32.
|
|
val_str = "{:f}".format(16777215)
|
|
|
|
# When using REPR_C, 16777215.0 is the same as 16777212.0 or 16777214.4
|
|
# (depending on the implementation of pow() function, the result may differ)
|
|
if is_REPR_C and (val_str == "16777212.000000" or val_str == "16777214.400000"):
|
|
val_str = "16777215.000000"
|
|
|
|
print(val_str)
|
|
|
|
# 4294967040 = 16777215 * 128 is the largest integer that is exactly
|
|
# represented by a float32 and that will also fit within a (signed) int32.
|
|
# The upper bound of our integer-handling code is actually double this,
|
|
# but that constant might cause trouble on systems using 32 bit ints.
|
|
val_str = "{:f}".format(2147483520)
|
|
|
|
# When using FLOAT_IMPL_FLOAT, 2147483520.0 == 2147483500.0
|
|
# Both representations are valid, the second being "simpler"
|
|
is_float32 = float("1e300") == float("inf")
|
|
if is_float32 and val_str == "2147483500.000000":
|
|
val_str = "2147483520.000000"
|
|
|
|
# When using REPR_C, 2147483520.0 is the same as 2147483200.0
|
|
# Both representations are valid, the second being "simpler"
|
|
if is_REPR_C and val_str == "2147483200.000000":
|
|
val_str = "2147483520.000000"
|
|
|
|
print(val_str)
|
|
|
|
# Very large positive integers can be a test for precision and resolution.
|
|
# This is a weird way to represent 1e38 (largest power of 10 for float32).
|
|
print("{:.6e}".format(float("9" * 30 + "e8")))
|