Lines Matching +full:big +full:- +full:tests
13 MASK = BASE - 1
25 special.append(p2 - 1)
29 special += [~x for x in special] + [-x for x in special]
35 DBL_MIN_OVERFLOW = 2**DBL_MAX_EXP - 2**(DBL_MAX_EXP - DBL_MANT_DIG - 1)
38 # Pure Python version of correctly-rounded integer-to-float conversion.
41 Correctly-rounded integer-to-float conversion.
44 # Constants, depending only on the floating-point format in use.
47 SHIFT_MAX = sys.float_info.max_exp - PRECISION
49 ROUND_HALF_TO_EVEN_CORRECTION = [0, -1, -2, 1, 0, -1, 2, 1]
55 return -int_to_float(-n)
57 # Convert n to a 'floating-point' number q * 2**shift, where q is an
62 shift = n.bit_length() - PRECISION
63 q = n << -shift if shift < 0 else (n >> shift) | bool(n & ~(-1 << shift))
77 # Some circularity here, since float(q) is doing an int-to-float
79 # as a float. In a low-level C-like language, this operation would be a
84 # pure Python version of correctly-rounded true division
86 """Correctly-rounded true division for integers."""
96 # find integer d satisfying 2**(d - 1) <= a/b < 2**d
97 d = a.bit_length() - b.bit_length()
98 if d >= 0 and a >= 2**d * b or d < 0 and a * 2**-d >= b:
101 # compute 2**-exp * a / b for suitable exp
102 exp = max(d, DBL_MIN_EXP) - DBL_MANT_DIG
103 a, b = a << max(-exp, 0), b << max(exp, 0)
106 # round-half-to-even: fractional part is r/b, which is > 0.5 iff
112 return -result if negative else result
117 # Get quasi-random long consisting of ndigits digits (in base BASE).
118 # quasi == the most-significant digit will not be 0, and the number
120 # more likely than random bits to provoke digit-boundary errors.
126 nbits_lo = nbits_hi - SHIFT + 1
132 bits = min(bits, nbits_hi - nbits)
137 answer = answer | ((1 << bits) - 1)
141 answer = -answer
152 answer = -answer
183 # 30-bit cases involving a quotient digit estimate of BASE+1
192 # 30-bit cases that require the post-subtraction correction step
198 # 15-bit cases involving a quotient digit estimate of BASE+1
203 # 15-bit cases that require the post-subtraction correction step
216 # Test products of long strings of 1 bits -- (2**x-1)*(2**y-1) ==
217 # 2**(x+y) - 2**x - 2**y + 1, so the proper result is easy to check.
219 a = (1 << abits) - 1
224 b = (1 << bbits) - 1
226 y = ((1 << (abits + bbits)) -
227 (1 << abits) -
238 eq(x & -1, x)
239 eq(x | -1, -1)
240 eq(x ^ -1, ~x)
246 eq(x | ~x, -1)
247 eq(x ^ ~x, -1)
248 eq(-x, 1 + ~x)
249 eq(-x, ~(x-1))
256 eq(x & -p2, x >> n << n)
257 eq(x & -p2, x & ~(p2 - 1))
297 sign, x = 1, -x
303 return '-'[:sign] + \
331 for sign in "", "+", "-":
335 if sign == "-" and v is not ValueError:
336 vv = -v
346 self.assertRaises(ValueError, int, '-37L')
352 # tests with base 0
362 self.assertEqual(int('-0', 0), 0)
365 self.assertRaises(ValueError, int, '-012395', 0)
368 invalid_bases = [-909,
369 2**31-1, 2**31, -2**31, -2**31-1,
370 2**63-1, 2**63, -2**63, -2**63-1,
371 2**100, -2**100,
377 # See bpo-34087
399 # Check that int -> float conversion behaviour matches
419 2**53-3,
420 2**53-2,
421 2**53-1,
424 2**54-4,
425 2**54-2,
430 self.assertEqual(float(-x), -x)
432 # test round-half-even
443 # behaviour near extremes of floating-point range
449 self.assertEqual(float(halfway-1), DBL_MAX)
451 self.assertEqual(float(1-halfway), -DBL_MAX)
452 self.assertRaises(OverflowError, float, -halfway)
453 self.assertRaises(OverflowError, float, top_power-1)
456 self.assertRaises(OverflowError, float, 2*top_power-1)
472 int_dbl_max-1, int_dbl_max, int_dbl_max+1,
473 halfway-1, halfway, halfway + 1,
474 top_power-1, top_power, top_power+1,
475 2*top_power-1, 2*top_power, top_power*top_power,
478 for p in range(-4, 8):
479 for x in range(-128, 128):
483 self.check_float_conversion(-value)
486 for x in -2.0, -1.0, 0.0, 1.0, 2.0:
491 mhuge = -huge
498 "1. - huge", "huge - 1.", "1. - mhuge", "mhuge - 1.",
530 for bad in -(1 << 10000), -2, 0:
554 # up all bits in 2 iterations for all known binary double-
564 f -= digit
566 e -= CHUNK
574 d = 1 << -e
576 n = -n
587 return (x > y) - (x < y)
603 cases.extend([t - 1.0, t - 0.3, t, t + 0.3, t + 1.0,
604 int(t-1), int(t), int(t+1)])
609 cases.extend([0, 1, 2, 1 << 20000, t-1, t, t+1])
610 cases.extend([-x for x in cases])
615 Rcmp = (Rx > Ry) - (Rx < Ry)
617 xycmp = (x > y) - (x < y)
633 self.assertEqual(format(1, "-"), '1')
634 self.assertEqual(format(-1, "-"), '-1')
635 self.assertEqual(format(1, "-3"), ' 1')
636 self.assertEqual(format(-1, "-3"), ' -1')
638 self.assertEqual(format(-1, "+3"), ' -1')
640 self.assertEqual(format(-1, " 3"), ' -1')
642 self.assertEqual(format(-1, " "), '-1')
648 self.assertEqual(format(-1234, "x"), "-4d2")
650 self.assertEqual(format(-1234, "8x"), " -4d2")
652 self.assertEqual(format(-1234, "x"), "-4d2")
653 self.assertEqual(format(-3, "x"), "-3")
654 self.assertEqual(format(-3, "X"), "-3")
657 self.assertEqual(format(-int('be', 16), "x"), "-be")
658 self.assertEqual(format(-int('be', 16), "X"), "-BE")
665 self.assertEqual(format(-3, "o"), "-3")
667 self.assertEqual(format(-1234, "o"), "-2322")
668 self.assertEqual(format(1234, "-o"), "2322")
669 self.assertEqual(format(-1234, "-o"), "-2322")
671 self.assertEqual(format(-1234, " o"), "-2322")
673 self.assertEqual(format(-1234, "+o"), "-2322")
679 self.assertEqual(format(-3, "b"), "-11")
681 self.assertEqual(format(-1234, "b"), "-10011010010")
682 self.assertEqual(format(1234, "-b"), "10011010010")
683 self.assertEqual(format(-1234, "-b"), "-10011010010")
685 self.assertEqual(format(-1234, " b"), "-10011010010")
687 self.assertEqual(format(-1234, "+b"), "-10011010010")
712 self.assertRaises(ValueError, format, -1, format_spec)
714 self.assertRaises(ValueError, format, -(2**100), format_spec)
719 for value in [0, 1, -1, 100, -100, 1234567890, -1234567890]:
725 self.assertRaises(OverflowError, int, float('-inf'))
733 self.assertEqual(-13 % 10, 7)
734 self.assertEqual(13 % -10, -7)
735 self.assertEqual(-13 % -10, -3)
738 self.assertEqual(-12 % 4, 0)
739 self.assertEqual(12 % -4, 0)
740 self.assertEqual(-12 % -4, 0)
744 mhuge = -huge
747 self.assertEqual(huge / mhuge, -1.0)
748 self.assertEqual(mhuge / huge, -1.0)
755 self.assertEqual((666 * huge + (huge >> 1)) / mhuge, -666.5)
756 self.assertEqual((666 * mhuge + (mhuge >> 1)) / huge, -666.5)
763 "huge / 1", "huge / 2", "huge / -1", "huge / -2",
767 for underflow in ["1 / huge", "2 / huge", "-1 / huge", "-2 / huge",
781 self.assertEqual(2 // -3, -1)
782 self.assertEqual(-2 // 3, -1)
783 self.assertEqual(-2 // -3, 0)
785 self.assertEqual(-11 // -3, 3)
786 self.assertEqual(-11 // 3, -4)
787 self.assertEqual(11 // -3, -4)
790 self.assertEqual(-12 // -3, 4)
791 self.assertEqual(-12 // 3, -4)
792 self.assertEqual(12 // -3, -4)
802 # then applies a float division. This can give doubly-rounded
803 # results on x87-using machines (particularly 32-bit Linux).
808 # use repr so that we can distinguish between -0.0 and 0.0
827 # more stringent tests than those above, checking that the
829 # This test should probably be considered CPython-specific.
831 # Exercise all the code paths not involving Gb-sized ints.
834 self.check_truediv(-456, 0)
836 self.check_truediv(0, -3)
840 self.check_truediv(12345, 345678 * 2**(DBL_MANT_DIG - DBL_MIN_EXP))
845 # 2**DBL_MAX_EXP, 2**(DBL_MIN_EXP-DBL_MANT_DIG)
847 DBL_MAX_EXP, DBL_MIN_EXP - DBL_MANT_DIG)
849 for exp in range(base - 15, base + 15):
850 self.check_truediv(75312*2**max(exp, 0), 69187*2**max(-exp, 0))
851 self.check_truediv(69187*2**max(exp, 0), 75312*2**max(-exp, 0))
855 -1, -2, -5, -23, -67891, -41**50]:
856 for n in range(-10, 10):
858 self.check_truediv(m*DBL_MIN_OVERFLOW + n, -m)
864 # rounded down under round-half-to-even. The tiniest of
872 # 64-bit precision. On such machines, the next check would fail,
883 # test round-half-to-even behaviour, normal result
885 -1, -2, -5, -23, -67891, -41**50]:
886 for n in range(-10, 10):
889 # test round-half-to-even, subnormal result
890 for n in range(-20, 20):
895 # always be bounded by 2**-54 with equality possible only
902 self.check_truediv(-a, b)
903 self.check_truediv(a, -b)
904 self.check_truediv(-a, -b)
906 # and some (genuinely) random tests
913 self.check_truediv(x, -y)
914 self.check_truediv(-x, y)
915 self.check_truediv(-x, -y)
919 42 << -3
921 42 << -(1 << 1000)
923 42 >> -3
925 42 >> -(1 << 1000)
931 0 << -1
934 0 << -(1 << 1000)
952 self.assertEqual((-42) >> huge_shift, -1)
954 self.assertEqual((-1123) >> huge_shift, -1)
956 self.assertEqual(-2**128 >> huge_shift, -1)
967 self.assertEqual((-42) >> 1, -21)
969 self.assertEqual((-43) >> 1, -22)
972 self.assertEqual((-1122) >> 1, -561)
974 self.assertEqual((-1123) >> 1, -562)
977 self.assertEqual(-2**128 >> 1, -2**127)
979 self.assertEqual(-(2**128 + 1) >> 1, -2**127 - 1)
983 self.assertEqual((-42) >> 9, -1)
985 self.assertEqual((-1122) >> 9, -3)
987 self.assertEqual(-2**128 >> 9, -2**119)
989 # shifting a two-limb int by the limb size still has two limbs.
990 self.assertEqual((1 - BASE*BASE) >> SHIFT, -BASE)
991 self.assertEqual((BASE - 1 - BASE*BASE) >> SHIFT, -BASE)
995 self.assertEqual((-42) >> 32, -1)
997 self.assertEqual((-1122) >> 32, -1)
999 self.assertEqual(-2**128 >> 32, -2**96)
1003 self.assertEqual((-42) << 1, -84)
1005 self.assertEqual((-561) << 1, -1122)
1007 self.assertEqual(-2**127 << 1, -2**128)
1011 self.assertEqual((-42) << 9, -21504)
1013 self.assertEqual((-1122) << 9, -574464)
1017 self.assertEqual((-42) << 32, -42 * 2**32)
1019 self.assertEqual((-1122) << 32, -1122 * 2**32)
1021 self.assertEqual(-2**128 << 32, -2**160)
1026 b = -a + 1
1029 self.assertIs(c - a, 1)
1038 self.assertIs(pow(2, 31, 2 ** 31 - 1), 1)
1039 self.assertIs(2 ** 31 % (2 ** 31 - 1), 1)
1040 a, p, m = 2, 31, 2 ** 31 - 1
1043 self.assertIs(pow(2, 100, 2**100 - 3), 3)
1044 self.assertIs(2 ** 100 % (2 ** 100 - 3), 3)
1045 a, p, m = 2, 100, 2**100 - 3
1050 big = 10 ** 100
1052 self.assertIs((big + 1) % big, 1)
1053 self.assertIs((big + 1) // big, 1)
1054 self.assertIs(big // (big // 2), 2)
1055 self.assertIs(big // (big // -4), -4)
1057 q, r = divmod(2 * big + 3, big)
1061 q, r = divmod(-4 * big + 100, big)
1062 self.assertIs(q, -4)
1065 q, r = divmod(3 * (-big) - 1, -big)
1067 self.assertIs(r, -1)
1069 q, r = divmod(3 * big - 1, -big)
1070 self.assertIs(q, -3)
1071 self.assertIs(r, -1)
1074 for i in range(-5, 257):
1077 self.assertIs(i, i - 0)
1079 self.assertIs(i, i & -1)
1088 self.assertIs(i - i, 0)
1092 tiny = 1e-10
1093 for x in range(-65000, 65000):
1096 self.assertEqual(k, len(bin(x).lstrip('-0b')))
1099 self.assertTrue(2**(k-1) <= abs(x) < 2**k)
1113 self.assertEqual((-1).bit_length(), 1)
1115 self.assertEqual((-2).bit_length(), 2)
1118 self.assertEqual((a-1).bit_length(), i)
1119 self.assertEqual((1-a).bit_length(), i)
1121 self.assertEqual((-a).bit_length(), i+1)
1123 self.assertEqual((-a-1).bit_length(), i+1)
1126 for a in range(-1000, 1000):
1132 self.assertEqual((a - 1).bit_count(), exp)
1134 self.assertEqual(((a - 1) ^ 510).bit_count(), exp - 8)
1137 # check round-half-even algorithm. For round to nearest ten;
1142 for offset in range(-520, 520, 20):
1144 got = round(k+offset, -1)
1150 self.assertEqual(round(-150, -2), -200)
1151 self.assertEqual(round(-149, -2), -100)
1152 self.assertEqual(round(-51, -2), -100)
1153 self.assertEqual(round(-50, -2), 0)
1154 self.assertEqual(round(-49, -2), 0)
1155 self.assertEqual(round(-1, -2), 0)
1156 self.assertEqual(round(0, -2), 0)
1157 self.assertEqual(round(1, -2), 0)
1158 self.assertEqual(round(49, -2), 0)
1159 self.assertEqual(round(50, -2), 0)
1160 self.assertEqual(round(51, -2), 100)
1161 self.assertEqual(round(149, -2), 100)
1162 self.assertEqual(round(150, -2), 200)
1163 self.assertEqual(round(250, -2), 200)
1164 self.assertEqual(round(251, -2), 300)
1165 self.assertEqual(round(172500, -3), 172000)
1166 self.assertEqual(round(173500, -3), 174000)
1167 self.assertEqual(round(31415926535, -1), 31415926540)
1168 self.assertEqual(round(31415926535, -2), 31415926500)
1169 self.assertEqual(round(31415926535, -3), 31415927000)
1170 self.assertEqual(round(31415926535, -4), 31415930000)
1171 self.assertEqual(round(31415926535, -5), 31415900000)
1172 self.assertEqual(round(31415926535, -6), 31416000000)
1173 self.assertEqual(round(31415926535, -7), 31420000000)
1174 self.assertEqual(round(31415926535, -8), 31400000000)
1175 self.assertEqual(round(31415926535, -9), 31000000000)
1176 self.assertEqual(round(31415926535, -10), 30000000000)
1177 self.assertEqual(round(31415926535, -11), 0)
1178 self.assertEqual(round(31415926535, -12), 0)
1179 self.assertEqual(round(31415926535, -999), 0)
1183 got = round(10**k + 324678, -3)
1191 x = random.randrange(-10000, 10000)
1195 for huge_n in 2**31-1, 2**31, 2**63-1, 2**63, 2**100, 10**100:
1200 x = random.randrange(-10000, 10000)
1211 def check(tests, byteorder, signed=False): argument
1215 elif byteorder == 'big':
1219 for test, expected in tests.items():
1230 if len(expected) == 1 and byteorder == 'big' and not signed:
1250 # Convert integers to signed big-endian byte arrays.
1254 -1: b'\xff',
1255 -127: b'\x81',
1256 -128: b'\x80',
1257 -129: b'\xff\x7f',
1260 -255: b'\xff\x01',
1261 -256: b'\xff\x00',
1265 -32768: b'\xff\x80\x00',
1267 -65536: b'\xff\x00\x00',
1268 -8388608: b'\x80\x00\x00'
1270 check(tests1, 'big', signed=True)
1272 # Convert integers to signed little-endian byte arrays.
1276 -1: b'\xff',
1277 -127: b'\x81',
1278 -128: b'\x80',
1279 -129: b'\x7f\xff',
1282 -255: b'\x01\xff',
1283 -256: b'\x00\xff',
1287 -32768: b'\x00\x80',
1289 -65536: b'\x00\x00\xff',
1290 -8388608: b'\x00\x00\x80'
1294 # Convert integers to unsigned big-endian byte arrays.
1307 check(tests3, 'big', signed=False)
1309 # Convert integers to unsigned little-endian byte arrays.
1324 self.assertRaises(OverflowError, (256).to_bytes, 1, 'big', signed=False)
1325 self.assertRaises(OverflowError, (256).to_bytes, 1, 'big', signed=True)
1328 self.assertRaises(OverflowError, (-1).to_bytes, 2, 'big', signed=False)
1329 self.assertRaises(OverflowError, (-1).to_bytes, 2, 'little', signed=False)
1330 self.assertEqual((0).to_bytes(0, 'big'), b'')
1331 self.assertEqual((1).to_bytes(5, 'big'), b'\x00\x00\x00\x00\x01')
1332 self.assertEqual((0).to_bytes(5, 'big'), b'\x00\x00\x00\x00\x00')
1333 self.assertEqual((-1).to_bytes(5, 'big', signed=True),
1335 self.assertRaises(OverflowError, (1).to_bytes, 0, 'big')
1337 # gh-98783
1340 self.assertEqual((0).to_bytes(1, SubStr('big')), b'\x00')
1344 def check(tests, byteorder, signed=False): argument
1348 elif byteorder == 'big':
1352 if signed and little_ordered and (little_ordered[-1] & 0x80):
1353 n -= 1 << 8*len(little_ordered)
1357 for test, expected in tests.items():
1368 if byteorder == 'big' and not signed:
1389 # Convert signed big-endian byte arrays to integers.
1396 b'\xff': -1,
1397 b'\xff\xff': -1,
1398 b'\x81': -127,
1399 b'\x80': -128,
1400 b'\xff\x7f': -129,
1403 b'\xff\x01': -255,
1404 b'\xff\x00': -256,
1408 b'\x80\x00': -32768,
1410 b'\xff\x00\x00': -65536,
1411 b'\x80\x00\x00': -8388608
1413 check(tests1, 'big', signed=True)
1415 # Convert signed little-endian byte arrays to integers.
1422 b'\xff': -1,
1423 b'\xff\xff': -1,
1424 b'\x81': -127,
1425 b'\x80': -128,
1426 b'\x7f\xff': -129,
1429 b'\x01\xff': -255,
1430 b'\x00\xff': -256,
1434 b'\x00\x80': -32768,
1436 b'\x00\x00\xff': -65536,
1437 b'\x00\x00\x80': -8388608
1441 # Convert unsigned big-endian byte arrays to integers.
1455 check(tests3, 'big', signed=False)
1457 # Convert integers to unsigned little-endian byte arrays.
1476 self.assertIs(type(myint.from_bytes(b'\x00', 'big')), myint)
1477 self.assertEqual(myint.from_bytes(b'\x01', 'big'), 1)
1479 type(myint.from_bytes(b'\x00', 'big', signed=False)), myint)
1480 self.assertEqual(myint.from_bytes(b'\x01', 'big', signed=False), 1)
1487 int.from_bytes([255, 0, 0], 'big', signed=True), -65536)
1489 int.from_bytes((255, 0, 0), 'big', signed=True), -65536)
1491 bytearray(b'\xff\x00\x00'), 'big', signed=True), -65536)
1493 bytearray(b'\xff\x00\x00'), 'big', signed=True), -65536)
1495 array.array('B', b'\xff\x00\x00'), 'big', signed=True), -65536)
1497 memoryview(b'\xff\x00\x00'), 'big', signed=True), -65536)
1498 self.assertRaises(ValueError, int.from_bytes, [256], 'big')
1499 self.assertRaises(ValueError, int.from_bytes, [0], 'big\x00')
1501 self.assertRaises(TypeError, int.from_bytes, "", 'big')
1502 self.assertRaises(TypeError, int.from_bytes, "\x00", 'big')
1503 self.assertRaises(TypeError, int.from_bytes, 0, 'big')
1504 self.assertRaises(TypeError, int.from_bytes, 0, 'big', True)
1505 self.assertRaises(TypeError, myint.from_bytes, "", 'big')
1506 self.assertRaises(TypeError, myint.from_bytes, "\x00", 'big')
1507 self.assertRaises(TypeError, myint.from_bytes, 0, 'big')
1508 self.assertRaises(TypeError, int.from_bytes, 0, 'big', True)
1514 i = myint2.from_bytes(b'\x01', 'big')
1522 i = myint3.from_bytes(b'\x01', 'big')
1543 # gh-98783
1546 self.assertEqual(int.from_bytes(b'', SubStr('big')), 0)
1551 # bpo-46361
1552 for i in range(-5, 257):
1580 tests = [10, 0, -10, 1, sys.maxsize + 1, True, False, myint(42)]
1581 for value in tests:
1593 n = (1 << bitlen) - 1 # solid string of 1 bits
1595 # (2**i - 1)**2 = 2**(2*i) - 2*2**i + 1
1597 (1 << (2 * bitlen)) - (1 << (bitlen + 1)) + 1)