mirror of
https://github.com/licsber/micropython.git
synced 2024-09-20 09:00:23 +08:00
f31f9a8b70
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.
105 lines
2.8 KiB
Python
105 lines
2.8 KiB
Python
# check cases converting float to int, requiring double precision float
|
|
|
|
try:
|
|
import ustruct as struct
|
|
except:
|
|
import struct
|
|
|
|
import sys
|
|
|
|
maxsize_bits = 0
|
|
maxsize = sys.maxsize
|
|
while maxsize:
|
|
maxsize >>= 1
|
|
maxsize_bits += 1
|
|
|
|
# work out configuration values
|
|
is_64bit = maxsize_bits > 32
|
|
# 0 = none, 1 = long long, 2 = mpz
|
|
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:
|
|
ll_type = 1
|
|
else:
|
|
ll_type = 2
|
|
|
|
# This case occurs with time.time() values
|
|
if ll_type != 0:
|
|
print(int(1418774543.0))
|
|
print("%d" % 1418774543.0)
|
|
if ll_type == 3:
|
|
print(int(2.0 ** 100))
|
|
print("%d" % 2.0 ** 100)
|
|
else:
|
|
print(int(1073741823.0))
|
|
print("%d" % 1073741823.0)
|
|
|
|
testpass = True
|
|
p2_rng = ((30, 63, 1024), (62, 63, 1024))[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"))
|
|
|
|
testpass = True
|
|
p10_rng = ((9, 18, 23), (18, 18, 23))[is_64bit][ll_type]
|
|
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"))
|
|
|
|
|
|
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"))
|
|
|
|
|
|
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.9999999999999981 * 2.0 ** 1023.0, "large neg", False)
|
|
fp2int_test(1.9999999999999981 * 2.0 ** 1023.0, "large pos", False)
|
|
|
|
fp2int_test(float("inf"), "inf test", True)
|
|
fp2int_test(float("-inf"), "inf test", True)
|
|
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))
|