diff --git a/tests/float/float2int.py b/tests/float/float2int.py index 4629642874..ca395997c4 100644 --- a/tests/float/float2int.py +++ b/tests/float/float2int.py @@ -1,12 +1,33 @@ # check cases converting float to int, relying only on single precision float +import struct + +# work out configuration values +is_64bit = struct.calcsize("P") == 8 +# 0 = none, 1 = long long, 2 = mpz +try: + dummy = 0x7fffffffffffffff + try: + if (0xffffffffffffffff + 1) > 0: + ll_type = 2 + else: + ll_type = 1 + except: + # in case the sum in the if statement above changes to raising an exception on overflow + ll_type = 1 +except: + ll_type = 0 + +# basic conversion print(int(14187745.)) -print(int(2.**100)) print("%d" % 14187745.) -print("%d" % 2.**100) +if ll_type == 2: + print(int(2.**100)) + print("%d" % 2.**100) testpass = True -for i in range(0,128): +p2_rng = ((30,63,127),(62,63,127))[is_64bit][ll_type] +for i in range(0,p2_rng): bitcnt = len(bin(int(2.**i))) - 3; if i != bitcnt: print('fail: 2**%u was %u bits long' % (i, bitcnt)); @@ -15,25 +36,51 @@ 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 -for i in range(0,12): +p10_rng = 9 if (ll_type == 0 and ~is_64bit) else 11 +for i in range(0,p10_rng): digcnt = len(str(int(10.**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')) -# test inf conversion -try: - int(float('inf')) -except OverflowError: - print("OverflowError") +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')) -# test nan conversion -try: - int(float('nan')) -except ValueError: - print("ValueError") +if ll_type != 2: + if ll_type == 0: + if is_64bit: + neg_bad_fp = -1.00000005*2.**62. + pos_bad_fp = 2.**62. + neg_good_fp = -2.**62. + pos_good_fp = 0.99999993*2.**62. + else: + neg_bad_fp = -1.00000005*2.**30. + pos_bad_fp = 2.**30. + neg_good_fp = -2.**30. + pos_good_fp = 0.9999999499*2.**30. + else: + neg_bad_fp = -0.51*2.**64. + pos_bad_fp = 2.**63. + neg_good_fp = -2.**63. + pos_good_fp = 1.9999998*2.**62. + + 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.**127., 'large neg', False) + fp2int_test(1.999999879*2.**127., 'large pos', False) + +fp2int_test(float('inf'), 'inf test', True) +fp2int_test(float('nan'), 'NaN test', True) # test numbers < 1 (this used to fail; see issue #1044) -import struct +fp2int_test(0.0001, 'small num', False) struct.pack('I', int(1/2)) diff --git a/tests/float/float2int_doubleprec.py b/tests/float/float2int_doubleprec.py index c6fe3783e6..63138c0d4e 100644 --- a/tests/float/float2int_doubleprec.py +++ b/tests/float/float2int_doubleprec.py @@ -1,11 +1,37 @@ # check cases converting float to int, requiring double precision float +import struct + +# work out configuration values +is_64bit = struct.calcsize("P") == 8 +# 0 = none, 1 = long long, 2 = mpz +try: + dummy = 0x7fffffffffffffff + try: + if (0xffffffffffffffff + 1) > 0: + ll_type = 2 + else: + ll_type = 1 + except: + # in case the sum in the if statement above changes to raising an exception on overflow + ll_type = 1 +except: + ll_type = 0 + # This case occurs with time.time() values -print(int(1418774543.)) -print("%d" % 1418774543.) +if ll_type != 0: + print(int(1418774543.)) + print("%d" % 1418774543.) + if ll_type == 3: + print(int(2.**100)) + print("%d" % 2.**100) +else: + print(int(1073741823.)) + print("%d" % 1073741823.) testpass = True -for i in range(0,1024): +p2_rng = ((30,63,1024),(62,63,1024))[is_64bit][ll_type] +for i in range(0,p2_rng): bitcnt = len(bin(int(2.**i))) - 3; if i != bitcnt: print('fail: 2**%u was %u bits long' % (i, bitcnt)); @@ -13,9 +39,51 @@ for i in range(0,1024): print("power of 2 test: %s" % (testpass and 'passed' or 'failed')) testpass = True -for i in range(0,23): +p10_rng = ((9,18,23),(18,18,23))[is_64bit][ll_type] +for i in range(0,p10_rng): digcnt = len(str(int(10.**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.**62. + pos_bad_fp = 2.**62. + neg_good_fp = -2.**62. + pos_good_fp = 0.99999993*2.**62. + else: + neg_bad_fp = -1.00000005*2.**30. + pos_bad_fp = 2.**30. + neg_good_fp = -2.**30. + pos_good_fp = 0.9999999499*2.**30. + else: + neg_bad_fp = -0.51*2.**64. + pos_bad_fp = 2.**63. + neg_good_fp = -2.**63. + pos_good_fp = 1.9999998*2.**62. + + 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.**1023., 'large neg', False) + fp2int_test(1.9999999999999981*2.**1023., 'large pos', False) + +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))