djsundog
/
circuitpython
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
circuitpython/tests/float/float2int_fp30_intbig.py

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

98 lines
2.6 KiB
Python
Raw Normal View History

test/float2int_fp30: Variant of float2int for 30-bit stuffed float.
2016-02-13 09:59:50 -05:00
# check cases converting float to int, relying only on single precision float
tests: Replace umodule with module everywhere. This work was funded through GitHub Sponsors. Signed-off-by: Jim Mussared <jim.mussared@gmail.com>
2022-08-18 02:57:45 -04:00
import struct
import sys
tests: Format all Python code with black, except tests in basics subdir. This adds the Python files in the tests/ directory to be formatted with ./tools/codeformat.py. The basics/ subdirectory is excluded for now so we aren't changing too much at once. In a few places `# fmt: off`/`# fmt: on` was used where the code had special formatting for readability or where the test was actually testing the specific formatting.
2020-03-22 22:26:08 -04:00
float/float2int*: Make actually be parsable for MICROPY_LONGINT_IMPL_NONE. The use of large literal numbers is a big no-no when it comes to writing programs which work with different int representations. Also, some checks are pretty adhoc (e.g using struct module to check for 64-bitness). This change bases entire detection on sys.maxsize and integer operarions, and thus more correct, even if longer. Note that this change doesn't mean that any of these tests can pass with anything but MPZ - even despite checking for various int representations, the tests aren't written to be portable among them.
2017-03-06 10:23:09 -05:00
maxsize_bits = 0
maxsize = sys.maxsize
while maxsize:
maxsize >>= 1
maxsize_bits += 1
test/float2int_fp30: Variant of float2int for 30-bit stuffed float.
2016-02-13 09:59:50 -05:00
# work out configuration values
float/float2int*: Make actually be parsable for MICROPY_LONGINT_IMPL_NONE. The use of large literal numbers is a big no-no when it comes to writing programs which work with different int representations. Also, some checks are pretty adhoc (e.g using struct module to check for 64-bitness). This change bases entire detection on sys.maxsize and integer operarions, and thus more correct, even if longer. Note that this change doesn't mean that any of these tests can pass with anything but MPZ - even despite checking for various int representations, the tests aren't written to be portable among them.
2017-03-06 10:23:09 -05:00
is_64bit = maxsize_bits > 32
test/float2int_fp30: Variant of float2int for 30-bit stuffed float.
2016-02-13 09:59:50 -05:00
# 0 = none, 1 = long long, 2 = mpz
float/float2int*: Make actually be parsable for MICROPY_LONGINT_IMPL_NONE. The use of large literal numbers is a big no-no when it comes to writing programs which work with different int representations. Also, some checks are pretty adhoc (e.g using struct module to check for 64-bitness). This change bases entire detection on sys.maxsize and integer operarions, and thus more correct, even if longer. Note that this change doesn't mean that any of these tests can pass with anything but MPZ - even despite checking for various int representations, the tests aren't written to be portable among them.
2017-03-06 10:23:09 -05:00
ll_type = None
if is_64bit:
if maxsize_bits < 63:
ll_type = 0
else:
if maxsize_bits < 31:
ll_type = 0
if ll_type is None:
one = 1
if one << 65 < one << 62:
test/float2int_fp30: Variant of float2int for 30-bit stuffed float.
2016-02-13 09:59:50 -05:00
ll_type = 1
float/float2int*: Make actually be parsable for MICROPY_LONGINT_IMPL_NONE. The use of large literal numbers is a big no-no when it comes to writing programs which work with different int representations. Also, some checks are pretty adhoc (e.g using struct module to check for 64-bitness). This change bases entire detection on sys.maxsize and integer operarions, and thus more correct, even if longer. Note that this change doesn't mean that any of these tests can pass with anything but MPZ - even despite checking for various int representations, the tests aren't written to be portable among them.
2017-03-06 10:23:09 -05:00
else:
ll_type = 2
test/float2int_fp30: Variant of float2int for 30-bit stuffed float.
2016-02-13 09:59:50 -05:00
# basic conversion
print(int(14187744.0))
print("%d" % 14187744.0)
if ll_type == 2:
print(int(2.0**100))
print("%d" % 2.0**100)
testpass = True
p2_rng = ((30, 63, 127), (62, 63, 127))[is_64bit][ll_type]
for i in range(0, p2_rng):
bitcnt = len(bin(int(2.0**i))) - 3
if i != bitcnt:
print("fail: 2.**%u was %u bits long" % (i, bitcnt))
testpass = False
print("power of 2 test: %s" % (testpass and "passed" or "failed"))
# TODO why does 10**12 fail this test for single precision float?
testpass = True
p10_rng = 9
for i in range(0, p10_rng):
digcnt = len(str(int(10.0**i))) - 1
if i != digcnt:
print("fail: 10.**%u was %u digits long" % (i, digcnt))
testpass = False
print("power of 10 test: %s" % (testpass and "passed" or "failed"))
tests: Format all Python code with black, except tests in basics subdir. This adds the Python files in the tests/ directory to be formatted with ./tools/codeformat.py. The basics/ subdirectory is excluded for now so we aren't changing too much at once. In a few places `# fmt: off`/`# fmt: on` was used where the code had special formatting for readability or where the test was actually testing the specific formatting.
2020-03-22 22:26:08 -04:00
test/float2int_fp30: Variant of float2int for 30-bit stuffed float.
2016-02-13 09:59:50 -05:00
def fp2int_test(num, name, should_fail):
try:
x = int(num)
passed = ~should_fail
except:
passed = should_fail
print("%s: %s" % (name, passed and "passed" or "failed"))
tests: Format all Python code with black, except tests in basics subdir. This adds the Python files in the tests/ directory to be formatted with ./tools/codeformat.py. The basics/ subdirectory is excluded for now so we aren't changing too much at once. In a few places `# fmt: off`/`# fmt: on` was used where the code had special formatting for readability or where the test was actually testing the specific formatting.
2020-03-22 22:26:08 -04:00
test/float2int_fp30: Variant of float2int for 30-bit stuffed float.
2016-02-13 09:59:50 -05:00
if ll_type != 2:
if ll_type == 0:
if is_64bit:
neg_bad_fp = -1.00000005 * 2.0**62.0
pos_bad_fp = 2.0**62.0
neg_good_fp = -(2.0**62.0)
pos_good_fp = 0.99999993 * 2.0**62.0
else:
neg_bad_fp = -1.00000005 * 2.0**30.0
pos_bad_fp = 2.0**30.0
neg_good_fp = -(2.0**30.0)
pos_good_fp = 0.9999999499 * 2.0**30.0
else:
neg_bad_fp = -0.51 * 2.0**64.0
pos_bad_fp = 2.0**63.0
neg_good_fp = -(2.0**63.0)
pos_good_fp = 1.9999998 * 2.0**62.0
fp2int_test(neg_bad_fp, "neg bad", True)
fp2int_test(pos_bad_fp, "pos bad", True)
fp2int_test(neg_good_fp, "neg good", False)
fp2int_test(pos_good_fp, "pos good", False)
else:
fp2int_test(-1.999999879 * 2.0**126.0, "large neg", False)
fp2int_test(1.999999879 * 2.0**126.0, "large pos", False)
fp2int_test(float("inf"), "inf test", True)
py/objint: Do not use fpclassify. For combinations of certain versions of glibc and gcc the definition of fpclassify always takes float as argument instead of adapting itself to float/double/long double as required by the C99 standard. At the time of writing this happens for instance for glibc 2.27 with gcc 7.5.0 when compiled with -Os and glibc 3.0.7 with gcc 9.3.0. When calling fpclassify with double as argument, as in objint.c, this results in an implicit narrowing conversion which is not really correct plus results in a warning when compiled with -Wfloat-conversion. So fix this by spelling out the logic manually.
2020-04-06 04:44:48 -04:00
fp2int_test(float("-inf"), "inf test", True)
test/float2int_fp30: Variant of float2int for 30-bit stuffed float.
2016-02-13 09:59:50 -05:00
fp2int_test(float("nan"), "NaN test", True)
# test numbers < 1 (this used to fail; see issue #1044)
fp2int_test(0.0001, "small num", False)
struct.pack("I", int(1 / 2))