Lines Matching refs:Decimal
11 These are the test cases for the Decimal module.
14 the Decimal arithmetic using the tests provided by Mike Cowlishaw. The latter
137 """Class which tests the Decimal class against the IBM test cases."""
156 # Decimal behaves differently from decNumber for these testcases so these
202 # Name adapter to be able to change the Decimal and Context
267 # Decimal instance.
292 return self.decimal.Decimal(v, context)
496 # The following classes test the behaviour of Decimal according to PEP 327
499 '''Unit tests for Explicit Construction cases of Decimal.'''
502 Decimal = self.decimal.Decimal
503 self.assertEqual(Decimal(), Decimal("0"))
506 Decimal = self.decimal.Decimal
507 self.assertRaises(TypeError, Decimal, None)
510 Decimal = self.decimal.Decimal
513 d = Decimal(45)
517 d = Decimal(500000123)
521 d = Decimal(-45)
525 d = Decimal(0)
533 d = Decimal(i)
537 Decimal = self.decimal.Decimal
542 self.assertEqual(str(Decimal('')), 'NaN')
545 self.assertEqual(str(Decimal('45')), '45')
548 self.assertEqual(str(Decimal('45.34')), '45.34')
551 self.assertEqual(str(Decimal('45e2')), '4.5E+3')
554 self.assertEqual(str(Decimal('ugly')), 'NaN')
557 self.assertEqual(str(Decimal('1.3E4 \n')), '1.3E+4')
558 self.assertEqual(str(Decimal(' -7.89')), '-7.89')
559 self.assertEqual(str(Decimal(" 3.45679 ")), '3.45679')
562 self.assertEqual(str(Decimal('1_3.3e4_0')), '1.33E+41')
563 self.assertEqual(str(Decimal('1_0_0_0')), '1000')
568 self.assertEqual(str(Decimal(lead + '9.311E+28' + trail)),
574 self.assertRaises(InvalidOperation, Decimal, "xyz")
576 self.assertRaises(TypeError, Decimal, "1234", "x", "y")
579 self.assertRaises(InvalidOperation, Decimal, "1\u00a02\u00a03")
580 self.assertRaises(InvalidOperation, Decimal, "\u00a01\u00a02\u00a0")
583 self.assertRaises(InvalidOperation, Decimal, "\u00a0")
584 self.assertRaises(InvalidOperation, Decimal, "\u00a0\u00a0")
587 self.assertRaises(InvalidOperation, Decimal, "12\u00003")
590 self.assertRaises(InvalidOperation, Decimal, "1_2_\u00003")
597 Decimal = self.decimal.Decimal
601 self.assertEqual(str(Decimal(s)), '9.999999')
605 Decimal = self.decimal.Decimal
608 d = Decimal( (0, (0,), 0) )
612 d = Decimal( (1, (4, 5), 0) )
616 d = Decimal( (0, (4, 5, 3, 4), -2) )
620 d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
624 d = Decimal( (0, (), "F") )
628 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1)) )
631 self.assertRaises(ValueError, Decimal, (8, (4, 3, 4, 9, 1), 2) )
632 self.assertRaises(ValueError, Decimal, (0., (4, 3, 4, 9, 1), 2) )
633 self.assertRaises(ValueError, Decimal, (Decimal(1), (4, 3, 4, 9, 1), 2))
636 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), 'wrong!') )
637 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), 0.) )
638 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), '1') )
641 self.assertRaises(ValueError, Decimal, (1, "xyz", 2) )
642 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, None, 1), 2) )
643 self.assertRaises(ValueError, Decimal, (1, (4, -3, 4, 9, 1), 2) )
644 self.assertRaises(ValueError, Decimal, (1, (4, 10, 4, 9, 1), 2) )
645 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 'a', 1), 2) )
648 Decimal = self.decimal.Decimal
650 d = Decimal([0, [0], 0])
653 d = Decimal([1, [4, 3, 4, 9, 1, 3, 5, 3, 4], -25])
656 d = Decimal([1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25])
659 d = Decimal((1, [4, 3, 4, 9, 1, 3, 5, 3, 4], -25))
663 Decimal = self.decimal.Decimal
665 self.assertIs(bool(Decimal(0)), False)
666 self.assertIs(bool(Decimal(1)), True)
667 self.assertEqual(Decimal(False), Decimal(0))
668 self.assertEqual(Decimal(True), Decimal(1))
671 Decimal = self.decimal.Decimal
674 d = Decimal(45)
675 e = Decimal(d)
679 d = Decimal(500000123)
680 e = Decimal(d)
684 d = Decimal(-45)
685 e = Decimal(d)
689 d = Decimal(0)
690 e = Decimal(d)
696 Decimal = self.decimal.Decimal
698 r = Decimal(0.1)
699 self.assertEqual(type(r), Decimal)
702 self.assertTrue(Decimal(float('nan')).is_qnan())
703 self.assertTrue(Decimal(float('inf')).is_infinite())
704 self.assertTrue(Decimal(float('-inf')).is_infinite())
705 self.assertEqual(str(Decimal(float('nan'))),
706 str(Decimal('NaN')))
707 self.assertEqual(str(Decimal(float('inf'))),
708 str(Decimal('Infinity')))
709 self.assertEqual(str(Decimal(float('-inf'))),
710 str(Decimal('-Infinity')))
711 self.assertEqual(str(Decimal(float('-0.0'))),
712 str(Decimal('-0')))
715 self.assertEqual(x, float(Decimal(x))) # roundtrip
718 Decimal = self.decimal.Decimal
726 d = Decimal()
736 self.assertIsInstance(d, Decimal)
741 d = Decimal('456789')
751 d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
756 # from Decimal
757 prevdec = Decimal(500000123)
758 d = Decimal(prevdec)
770 self.assertTrue(isinstance(d, Decimal))
796 Decimal('NaN12345'))
803 self.assertEqual(str(nc.create_decimal(Decimal('NaN12345'))), 'NaN')
808 Decimal = self.decimal.Decimal
812 self.assertEqual(type(r), Decimal)
831 Decimal = self.decimal.Decimal
839 self.assertEqual(str(Decimal(input)), expected)
847 '''Unit tests for Implicit Construction cases of Decimal.'''
850 Decimal = self.decimal.Decimal
851 self.assertRaises(TypeError, eval, 'Decimal(5) + None', locals())
854 Decimal = self.decimal.Decimal
857 self.assertEqual(str(Decimal(5) + 45), '50')
859 self.assertEqual(Decimal(5) + 123456789000, Decimal(123456789000))
862 Decimal = self.decimal.Decimal
863 self.assertRaises(TypeError, eval, 'Decimal(5) + "3"', locals())
866 Decimal = self.decimal.Decimal
867 self.assertRaises(TypeError, eval, 'Decimal(5) + 2.2', locals())
870 Decimal = self.decimal.Decimal
871 self.assertEqual(Decimal(5) + Decimal(45), Decimal(50))
874 Decimal = self.decimal.Decimal
895 self.assertEqual(divmod(E(), Decimal(10)), 'divmod 10')
896 self.assertEqual(divmod(Decimal(10), E()), '10 rdivmod')
897 self.assertEqual(eval('Decimal(10) < E()'), 'gt 10')
898 self.assertEqual(eval('Decimal(10) > E()'), 'lt 10')
899 self.assertEqual(eval('Decimal(10) <= E()'), 'ge 10')
900 self.assertEqual(eval('Decimal(10) >= E()'), 'le 10')
901 self.assertEqual(eval('Decimal(10) == E()'), 'eq 10')
902 self.assertEqual(eval('Decimal(10) != E()'), 'ne 10')
918 self.assertEqual(eval('E()' + sym + 'Decimal(10)'),
920 self.assertEqual(eval('Decimal(10)' + sym + 'E()'),
931 Decimal = self.decimal.Decimal
933 # triples giving a format, a Decimal, and the expected result
1135 self.assertEqual(format(Decimal(d), fmt), result)
1138 self.assertRaises(TypeError, Decimal(1).__format__, b'-020')
1143 self.assertEqual(format(self.decimal.Decimal('-0.001'), 'z.2f'),
1147 self.assertRaises(ValueError, format, self.decimal.Decimal('1.23'), 'fz')
1150 Decimal = self.decimal.Decimal
1162 return Decimal(x).__format__(fmt, override)
1164 return Decimal(x).__format__(fmt, _localeconv=override)
1197 self.assertEqual(get_fmt(Decimal('12.7'), en_US), '12.7')
1198 self.assertEqual(get_fmt(Decimal('12.7'), fr_FR), '12,7')
1199 self.assertEqual(get_fmt(Decimal('12.7'), ru_RU), '12,7')
1200 self.assertEqual(get_fmt(Decimal('12.7'), crazy), '1-2&7')
1235 self.assertEqual(get_fmt(Decimal('-1.5'), dotsep_wide, '020n'),
1241 Decimal = self.decimal.Decimal
1252 self.assertEqual(format(Decimal('100000000.123'), 'n'),
1256 class A(self.decimal.Decimal):
1260 self.assertEqual(self.decimal.Decimal, a.a_type)
1263 self.assertEqual(self.decimal.Decimal, a.a_type)
1274 Decimal = self.decimal.Decimal
1276 d1 = Decimal('-11.1')
1277 d2 = Decimal('22.2')
1280 self.assertEqual(d1+d2, Decimal('11.1'))
1281 self.assertEqual(d2+d1, Decimal('11.1'))
1285 self.assertEqual(c, Decimal('-6.1'))
1290 self.assertEqual(c, Decimal('-6.1'))
1295 self.assertEqual(d1, Decimal('11.1'))
1299 self.assertEqual(d1, Decimal('16.1'))
1302 Decimal = self.decimal.Decimal
1304 d1 = Decimal('-11.1')
1305 d2 = Decimal('22.2')
1308 self.assertEqual(d1-d2, Decimal('-33.3'))
1309 self.assertEqual(d2-d1, Decimal('33.3'))
1313 self.assertEqual(c, Decimal('-16.1'))
1318 self.assertEqual(c, Decimal('16.1'))
1323 self.assertEqual(d1, Decimal('-33.3'))
1327 self.assertEqual(d1, Decimal('-38.3'))
1330 Decimal = self.decimal.Decimal
1332 d1 = Decimal('-5')
1333 d2 = Decimal('3')
1336 self.assertEqual(d1*d2, Decimal('-15'))
1337 self.assertEqual(d2*d1, Decimal('-15'))
1341 self.assertEqual(c, Decimal('-25'))
1346 self.assertEqual(c, Decimal('-25'))
1351 self.assertEqual(d1, Decimal('-15'))
1355 self.assertEqual(d1, Decimal('-75'))
1358 Decimal = self.decimal.Decimal
1360 d1 = Decimal('-5')
1361 d2 = Decimal('2')
1364 self.assertEqual(d1/d2, Decimal('-2.5'))
1365 self.assertEqual(d2/d1, Decimal('-0.4'))
1369 self.assertEqual(c, Decimal('-1.25'))
1374 self.assertEqual(c, Decimal('-0.8'))
1379 self.assertEqual(d1, Decimal('-2.5'))
1383 self.assertEqual(d1, Decimal('-0.625'))
1386 Decimal = self.decimal.Decimal
1388 d1 = Decimal('5')
1389 d2 = Decimal('2')
1392 self.assertEqual(d1//d2, Decimal('2'))
1393 self.assertEqual(d2//d1, Decimal('0'))
1397 self.assertEqual(c, Decimal('1'))
1402 self.assertEqual(c, Decimal('1'))
1407 self.assertEqual(d1, Decimal('2'))
1411 self.assertEqual(d1, Decimal('1'))
1414 Decimal = self.decimal.Decimal
1416 d1 = Decimal('5')
1417 d2 = Decimal('2')
1420 self.assertEqual(d1**d2, Decimal('25'))
1421 self.assertEqual(d2**d1, Decimal('32'))
1425 self.assertEqual(c, Decimal('625'))
1430 self.assertEqual(c, Decimal('16807'))
1435 self.assertEqual(d1, Decimal('25'))
1439 self.assertEqual(d1, Decimal('390625'))
1442 Decimal = self.decimal.Decimal
1444 d1 = Decimal('5')
1445 d2 = Decimal('2')
1448 self.assertEqual(d1%d2, Decimal('1'))
1449 self.assertEqual(d2%d1, Decimal('2'))
1453 self.assertEqual(c, Decimal('1'))
1458 self.assertEqual(c, Decimal('2'))
1463 self.assertEqual(d1, Decimal('1'))
1467 self.assertEqual(d1, Decimal('1'))
1470 Decimal = self.decimal.Decimal
1472 d1 = Decimal('5')
1473 d2 = Decimal('2')
1477 self.assertEqual(p, Decimal('2'))
1478 self.assertEqual(q, Decimal('1'))
1484 self.assertEqual(p, Decimal('1'))
1485 self.assertEqual(q, Decimal('1'))
1491 self.assertEqual(p, Decimal('1'))
1492 self.assertEqual(q, Decimal('2'))
1497 Decimal = self.decimal.Decimal
1499 self.assertEqual(+Decimal(45), Decimal(+45)) # +
1500 self.assertEqual(-Decimal(45), Decimal(-45)) # -
1501 self.assertEqual(abs(Decimal(45)), abs(Decimal(-45))) # abs
1511 Decimal = self.decimal.Decimal
1515 n = Decimal('NaN')
1516 s = Decimal('sNaN')
1517 i = Decimal('Inf')
1518 f = Decimal('2')
1559 Decimal = self.decimal.Decimal
1561 d = Decimal(1).copy_sign(Decimal(-2))
1562 self.assertEqual(Decimal(1).copy_sign(-2), d)
1563 self.assertRaises(TypeError, Decimal(1).copy_sign, '-2')
1573 Decimal = cls.decimal.Decimal
1582 d1 = Decimal(1)
1583 d3 = Decimal(3)
1597 cls.assertRaises(InvalidOperation, c3.compare, d1, Decimal('sNaN'))
1603 cls.assertEqual(test1, Decimal('0.333333333333333333333333'))
1604 cls.assertEqual(test2, Decimal('0.333333333333333333333333'))
1612 Decimal = cls.decimal.Decimal
1621 d1 = Decimal(1)
1622 d3 = Decimal(3)
1631 cls.assertRaises(Overflow, c2.multiply, Decimal('1e425000000'), 999)
1637 cls.assertRaises(Underflow, c3.divide, Decimal('1e-425000000'), 999)
1647 cls.assertEqual(test1, Decimal('0.333333333333333333333333'))
1648 cls.assertEqual(test2, Decimal('0.333333333333333333'))
1658 '''Unit tests for thread local contexts in Decimal.'''
1709 '''Unit tests for Usability cases of Decimal.'''
1713 Decimal = self.decimal.Decimal
1715 da = Decimal('23.42')
1716 db = Decimal('23.42')
1717 dc = Decimal('45')
1729 #a Decimal and an int
1734 #a Decimal and uncomparable
1741 a = list(map(Decimal, range(100)))
1748 Decimal = self.decimal.Decimal
1750 da = Decimal('0.25')
1751 db = Decimal('3.0')
1764 self.assertNotEqual(0.1, Decimal('0.1'))
1767 Decimal = self.decimal.Decimal
1769 da = Decimal('0.25')
1770 db = Decimal('3.0')
1787 D = self.decimal.Decimal
1829 Decimal = self.decimal.Decimal
1831 d = Decimal('43.24')
1839 Decimal = self.decimal.Decimal
1849 hashit(Decimal(23))
1850 hashit(Decimal('Infinity'))
1851 hashit(Decimal('-Infinity'))
1852 hashit(Decimal('nan123'))
1853 hashit(Decimal('-NaN'))
1855 test_values = [Decimal(sign*(2**m + n))
1861 Decimal("-1"), # ==> -2
1862 Decimal("-0"), # zeros
1863 Decimal("0.00"),
1864 Decimal("-0.000"),
1865 Decimal("0E10"),
1866 Decimal("-0E12"),
1867 Decimal("10.0"), # negative exponent
1868 Decimal("-23.00000"),
1869 Decimal("1230E100"), # positive exponent
1870 Decimal("-4.5678E50"),
1873 Decimal(2**64 + 2**32 - 1),
1876 Decimal("1.634E100"),
1877 Decimal("90.697E100"),
1878 Decimal("188.83E100"),
1879 Decimal("1652.9E100"),
1880 Decimal("56531E100"),
1887 # check that the hashes of a Decimal float match when they
1893 d = Decimal(s)
1899 x = Decimal("123456789.1")
1913 self.assertEqual(hashit(Decimal(x)), hashit(x))
1916 Decimal = self.decimal.Decimal
1917 self.assertRaises(TypeError, hash, Decimal('sNaN'))
1918 value = Decimal('NaN')
1923 class D(Decimal, H):
1929 Decimal = self.decimal.Decimal
1931 d1 = Decimal('15.32')
1932 d2 = Decimal('28.5')
1942 #between Decimal and int
1949 Decimal = self.decimal.Decimal
1952 self.assertFalse(Decimal(0))
1954 self.assertTrue(Decimal('0.372'))
1958 Decimal = self.decimal.Decimal
1960 d = Decimal('15.32')
1962 self.assertEqual(repr(d), "Decimal('15.32')") # repr
1966 Decimal = self.decimal.Decimal
1968 d1 = Decimal('66')
1969 d2 = Decimal('15.32')
1992 self.assertEqual(math.floor(Decimal(d)), i)
1993 self.assertRaises(ValueError, math.floor, Decimal('-NaN'))
1994 self.assertRaises(ValueError, math.floor, Decimal('sNaN'))
1995 self.assertRaises(ValueError, math.floor, Decimal('NaN123'))
1996 self.assertRaises(OverflowError, math.floor, Decimal('Inf'))
1997 self.assertRaises(OverflowError, math.floor, Decimal('-Inf'))
2012 self.assertEqual(math.ceil(Decimal(d)), i)
2013 self.assertRaises(ValueError, math.ceil, Decimal('-NaN'))
2014 self.assertRaises(ValueError, math.ceil, Decimal('sNaN'))
2015 self.assertRaises(ValueError, math.ceil, Decimal('NaN123'))
2016 self.assertRaises(OverflowError, math.ceil, Decimal('Inf'))
2017 self.assertRaises(OverflowError, math.ceil, Decimal('-Inf'))
2039 self.assertEqual(round(Decimal(d)), i)
2040 self.assertRaises(ValueError, round, Decimal('-NaN'))
2041 self.assertRaises(ValueError, round, Decimal('sNaN'))
2042 self.assertRaises(ValueError, round, Decimal('NaN123'))
2043 self.assertRaises(OverflowError, round, Decimal('Inf'))
2044 self.assertRaises(OverflowError, round, Decimal('-Inf'))
2065 self.assertEqual(str(round(Decimal(d), n)), r)
2070 Decimal = self.decimal.Decimal
2072 f = float(Decimal(s))
2078 Decimal = self.decimal.Decimal
2080 d = Decimal(s)
2084 Decimal = self.decimal.Decimal
2087 d = Decimal( (0, (0,), 0) )
2091 d = Decimal( (1, (4, 5), 0) )
2095 d = Decimal( (0, (4, 5, 3, 4), -2) )
2099 d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
2103 Decimal = self.decimal.Decimal
2106 d = Decimal(0)
2110 d = Decimal(-45)
2114 d = Decimal("-4.34913534E-17")
2119 d = Decimal("Infinity")
2123 d = Decimal( (0, (0, 0, 4, 0, 5, 3, 4), -2) )
2125 d = Decimal( (1, (0, 0, 0), 37) )
2127 d = Decimal( (1, (), 37) )
2131 d = Decimal( (0, (0, 0, 4, 0, 5, 3, 4), 'n') )
2133 d = Decimal( (1, (0, 0, 0), 'N') )
2135 d = Decimal( (1, (), 'n') )
2140 d = Decimal( (0, (0,), 'F') )
2142 d = Decimal( (0, (4, 5, 3, 4), 'F') )
2144 d = Decimal( (1, (0, 2, 7, 1), 'F') )
2148 Decimal = self.decimal.Decimal
2152 Decimal.as_integer_ratio, Decimal('inf'))
2154 Decimal.as_integer_ratio, Decimal('-inf'))
2156 Decimal.as_integer_ratio, Decimal('-nan'))
2158 Decimal.as_integer_ratio, Decimal('snan123'))
2163 d = Decimal('%s%dE%d' % (sign, coeff, exp))
2178 self.assertEqual(Decimal(p) / Decimal(q), d)
2181 # Different behaviours when subclassing Decimal
2182 Decimal = self.decimal.Decimal
2184 class MyDecimal(Decimal):
2190 self.assertIs(type(d), Decimal)
2193 self.assertIs(type(d), Decimal)
2203 # Decimal(Decimal)
2204 d = Decimal('1.0')
2205 x = Decimal(d)
2206 self.assertIs(type(x), Decimal)
2209 # MyDecimal(Decimal)
2215 # Decimal(MyDecimal)
2216 x = Decimal(m)
2217 self.assertIs(type(x), Decimal)
2228 Decimal = self.decimal.Decimal
2233 self.assertEqual(str(Decimal(0).sqrt()),
2234 str(c.sqrt(Decimal(0))))
2237 Decimal = self.decimal.Decimal
2254 x = Decimal("111")
2255 y = Decimal("1e9999")
2256 z = Decimal("1e-9999")
2275 self.assertRaises(InvalidOperation, Decimal(-1).ln, context=None)
2283 self.assertRaises(InvalidOperation, Decimal(-1).log10, context=None)
2288 self.assertRaises(DivisionByZero, Decimal(0).logb, context=None)
2298 self.assertRaises(InvalidOperation, Decimal('sNaN').next_minus, context=None)
2303 self.assertRaises(InvalidOperation, Decimal('sNaN').next_plus, context=None)
2331 ans = str(x.compare(Decimal('Nan891287828'), context=None))
2333 self.assertRaises(InvalidOperation, x.compare, Decimal('sNaN'), context=None)
2339 self.assertRaises(InvalidOperation, x.compare_signal, Decimal('NaN'), context=None)
2363 self.assertRaises(InvalidOperation, x.max, Decimal('sNaN'), context=None)
2369 self.assertRaises(InvalidOperation, x.max_mag, Decimal('sNaN'), context=None)
2375 self.assertRaises(InvalidOperation, x.min, Decimal('sNaN'), context=None)
2381 self.assertRaises(InvalidOperation, x.min_mag, Decimal('sNaN'), context=None)
2413 self.assertRaises(Overflow, x.fma, Decimal('1e9999'), 3, context=None)
2419 ans = str(Decimal('1.5').to_integral(rounding=None, context=None))
2422 ans = str(Decimal('1.5').to_integral(rounding=None, context=None))
2424 ans = str(Decimal('1.5').to_integral(rounding=ROUND_UP, context=None))
2427 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral, context=None)
2431 ans = str(Decimal('1.5').to_integral_value(rounding=None, context=None))
2434 ans = str(Decimal('1.5').to_integral_value(rounding=None, context=None))
2436 ans = str(Decimal('1.5').to_integral_value(rounding=ROUND_UP, context=None))
2439 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral_value, context=None)
2443 ans = str(Decimal('1.5').to_integral_exact(rounding=None, context=None))
2446 ans = str(Decimal('1.5').to_integral_exact(rounding=None, context=None))
2448 ans = str(Decimal('1.5').to_integral_exact(rounding=ROUND_UP, context=None))
2451 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral_exact, context=None)
2455 ans = str(Decimal('1.50001').quantize(exp=Decimal('1e-3'), rounding=None, context=None))
2458 ans = str(Decimal('1.50001').quantize(exp=Decimal('1e-3'), rounding=None, context=None))
2460 ans = str(Decimal('1.50001').quantize(exp=Decimal('1e-3'), rounding=ROUND_UP, context=None))
2463 self.assertRaises(InvalidOperation, y.quantize, Decimal('1e-10'), rounding=ROUND_UP, context=None)
2476 # Check that methods taking a second Decimal argument will
2477 # always accept an integer in place of a Decimal.
2478 Decimal = self.decimal.Decimal
2480 self.assertEqual(Decimal(4).compare(3),
2481 Decimal(4).compare(Decimal(3)))
2482 self.assertEqual(Decimal(4).compare_signal(3),
2483 Decimal(4).compare_signal(Decimal(3)))
2484 self.assertEqual(Decimal(4).compare_total(3),
2485 Decimal(4).compare_total(Decimal(3)))
2486 self.assertEqual(Decimal(4).compare_total_mag(3),
2487 Decimal(4).compare_total_mag(Decimal(3)))
2488 self.assertEqual(Decimal(10101).logical_and(1001),
2489 Decimal(10101).logical_and(Decimal(1001)))
2490 self.assertEqual(Decimal(10101).logical_or(1001),
2491 Decimal(10101).logical_or(Decimal(1001)))
2492 self.assertEqual(Decimal(10101).logical_xor(1001),
2493 Decimal(10101).logical_xor(Decimal(1001)))
2494 self.assertEqual(Decimal(567).max(123),
2495 Decimal(567).max(Decimal(123)))
2496 self.assertEqual(Decimal(567).max_mag(123),
2497 Decimal(567).max_mag(Decimal(123)))
2498 self.assertEqual(Decimal(567).min(123),
2499 Decimal(567).min(Decimal(123)))
2500 self.assertEqual(Decimal(567).min_mag(123),
2501 Decimal(567).min_mag(Decimal(123)))
2502 self.assertEqual(Decimal(567).next_toward(123),
2503 Decimal(567).next_toward(Decimal(123)))
2504 self.assertEqual(Decimal(1234).quantize(100),
2505 Decimal(1234).quantize(Decimal(100)))
2506 self.assertEqual(Decimal(768).remainder_near(1234),
2507 Decimal(768).remainder_near(Decimal(1234)))
2508 self.assertEqual(Decimal(123).rotate(1),
2509 Decimal(123).rotate(Decimal(1)))
2510 self.assertEqual(Decimal(1234).same_quantum(1000),
2511 Decimal(1234).same_quantum(Decimal(1000)))
2512 self.assertEqual(Decimal('9.123').scaleb(-100),
2513 Decimal('9.123').scaleb(Decimal(-100)))
2514 self.assertEqual(Decimal(456).shift(-1),
2515 Decimal(456).shift(Decimal(-1)))
2517 self.assertEqual(Decimal(-12).fma(Decimal(45), 67),
2518 Decimal(-12).fma(Decimal(45), Decimal(67)))
2519 self.assertEqual(Decimal(-12).fma(45, 67),
2520 Decimal(-12).fma(Decimal(45), Decimal(67)))
2521 self.assertEqual(Decimal(-12).fma(45, Decimal(67)),
2522 Decimal(-12).fma(Decimal(45), Decimal(67)))
2541 Decimal = self.decimal.Decimal
2543 self.assertTrue(issubclass(Decimal, numbers.Number))
2544 self.assertFalse(issubclass(Decimal, numbers.Real))
2545 self.assertIsInstance(Decimal(0), numbers.Number)
2546 self.assertNotIsInstance(Decimal(0), numbers.Real)
2550 Decimal = self.decimal.Decimal
2556 d = Decimal('-3.141590000')
2563 x = C.Decimal('-3.123e81723')
2564 y = P.Decimal('-3.123e81723')
2570 self.assertIsInstance(r, P.Decimal)
2577 self.assertIsInstance(r, C.Decimal)
2580 x = C.Decimal('-3.123e81723').as_tuple()
2581 y = P.Decimal('-3.123e81723').as_tuple()
2600 Decimal = self.decimal.Decimal
2605 self.assertEqual(int(Decimal(s)), int(float(s)))
2607 d = Decimal(s)
2609 self.assertEqual(Decimal(int(d)), r)
2611 self.assertRaises(ValueError, int, Decimal('-nan'))
2612 self.assertRaises(ValueError, int, Decimal('snan'))
2613 self.assertRaises(OverflowError, int, Decimal('inf'))
2614 self.assertRaises(OverflowError, int, Decimal('-inf'))
2618 Decimal = self.decimal.Decimal
2621 self.assertIs(int(Decimal(x)), x)
2624 Decimal = self.decimal.Decimal
2629 self.assertEqual(int(Decimal(s)), int(float(s)))
2631 d = Decimal(s)
2633 self.assertEqual(Decimal(math.trunc(d)), r)
2637 Decimal = self.decimal.Decimal
2639 class MyDecimal(Decimal):
2643 self.assertTrue(issubclass(MyDecimal, Decimal))
2657 str(Decimal('NaN')))
2659 str(Decimal('Infinity')))
2661 str(Decimal('-Infinity')))
2668 Decimal = self.decimal.Decimal
2675 Decimal('3.1415')
2680 Decimal('3.1416')
2689 "Decimal('-0')")
2691 "Decimal('1')")
2693 "Decimal('10')")
2696 Decimal = self.decimal.Decimal
2702 Decimal('7.335').quantize(Decimal('.01')),
2703 Decimal('7.34')
2706 Decimal('7.335').quantize(Decimal('.01'), rounding=ROUND_DOWN),
2707 Decimal('7.33')
2711 Decimal("10e99999").quantize, Decimal('1e100000'), context=c
2715 d = Decimal("0.871831e800")
2716 x = d.quantize(context=c, exp=Decimal("1e797"), rounding=ROUND_DOWN)
2717 self.assertEqual(x, Decimal('8.71E+799'))
2720 Decimal = self.decimal.Decimal
2722 x = Decimal("9.8182731e181273")
2727 x = Decimal("1")
2736 D = self.decimal.Decimal
2993 Decimal = self.decimal.Decimal
2995 self.assertIn(Decimal(10), ['a', 1.0, Decimal(10), (1,2), {}])
2996 self.assertNotIn(Decimal(10), ['a', 1.0, (1,2), {}])
3000 Decimal = self.decimal.Decimal
3025 Decimal = self.decimal.Decimal
3029 d = c.abs(Decimal(-1))
3034 Decimal = self.decimal.Decimal
3038 d = c.add(Decimal(1), Decimal(1))
3040 self.assertEqual(c.add(Decimal(1), 1), d)
3041 self.assertEqual(c.add(1, Decimal(1)), d)
3046 Decimal = self.decimal.Decimal
3050 d = c.compare(Decimal(1), Decimal(1))
3052 self.assertEqual(c.compare(Decimal(1), 1), d)
3053 self.assertEqual(c.compare(1, Decimal(1)), d)
3058 Decimal = self.decimal.Decimal
3062 d = c.compare_signal(Decimal(1), Decimal(1))
3064 self.assertEqual(c.compare_signal(Decimal(1), 1), d)
3065 self.assertEqual(c.compare_signal(1, Decimal(1)), d)
3070 Decimal = self.decimal.Decimal
3074 d = c.compare_total(Decimal(1), Decimal(1))
3076 self.assertEqual(c.compare_total(Decimal(1), 1), d)
3077 self.assertEqual(c.compare_total(1, Decimal(1)), d)
3082 Decimal = self.decimal.Decimal
3086 d = c.compare_total_mag(Decimal(1), Decimal(1))
3088 self.assertEqual(c.compare_total_mag(Decimal(1), 1), d)
3089 self.assertEqual(c.compare_total_mag(1, Decimal(1)), d)
3094 Decimal = self.decimal.Decimal
3098 d = c.copy_abs(Decimal(-1))
3103 Decimal = self.decimal.Decimal
3107 d = c.copy_decimal(Decimal(-1))
3112 Decimal = self.decimal.Decimal
3116 d = c.copy_negate(Decimal(-1))
3121 Decimal = self.decimal.Decimal
3125 d = c.copy_sign(Decimal(1), Decimal(-2))
3127 self.assertEqual(c.copy_sign(Decimal(1), -2), d)
3128 self.assertEqual(c.copy_sign(1, Decimal(-2)), d)
3133 Decimal = self.decimal.Decimal
3137 d = c.divide(Decimal(1), Decimal(2))
3139 self.assertEqual(c.divide(Decimal(1), 2), d)
3140 self.assertEqual(c.divide(1, Decimal(2)), d)
3145 Decimal = self.decimal.Decimal
3149 d = c.divide_int(Decimal(1), Decimal(2))
3151 self.assertEqual(c.divide_int(Decimal(1), 2), d)
3152 self.assertEqual(c.divide_int(1, Decimal(2)), d)
3157 Decimal = self.decimal.Decimal
3161 d = c.divmod(Decimal(1), Decimal(2))
3163 self.assertEqual(c.divmod(Decimal(1), 2), d)
3164 self.assertEqual(c.divmod(1, Decimal(2)), d)
3169 Decimal = self.decimal.Decimal
3173 d = c.exp(Decimal(10))
3178 Decimal = self.decimal.Decimal
3182 d = c.fma(Decimal(2), Decimal(3), Decimal(4))
3184 self.assertEqual(c.fma(Decimal(2), 3, 4), d)
3185 self.assertEqual(c.fma(2, Decimal(3), 4), d)
3186 self.assertEqual(c.fma(2, 3, Decimal(4)), d)
3187 self.assertEqual(c.fma(Decimal(2), Decimal(3), 4), d)
3194 Decimal('Infinity'), Decimal(0), "not a decimal")
3196 Decimal(1), Decimal('snan'), 1.222)
3197 # ... and for Decimal.fma.
3198 self.assertRaises(TypeError, Decimal('Infinity').fma,
3199 Decimal(0), "not a decimal")
3200 self.assertRaises(TypeError, Decimal(1).fma,
3201 Decimal('snan'), 1.222)
3204 Decimal = self.decimal.Decimal
3208 d = c.is_finite(Decimal(10))
3213 Decimal = self.decimal.Decimal
3217 d = c.is_infinite(Decimal(10))
3222 Decimal = self.decimal.Decimal
3226 d = c.is_nan(Decimal(10))
3231 Decimal = self.decimal.Decimal
3235 d = c.is_normal(Decimal(10))
3240 Decimal = self.decimal.Decimal
3244 d = c.is_qnan(Decimal(10))
3249 Decimal = self.decimal.Decimal
3253 d = c.is_signed(Decimal(10))
3258 Decimal = self.decimal.Decimal
3262 d = c.is_snan(Decimal(10))
3267 Decimal = self.decimal.Decimal
3271 d = c.is_subnormal(Decimal(10))
3276 Decimal = self.decimal.Decimal
3280 d = c.is_zero(Decimal(10))
3285 Decimal = self.decimal.Decimal
3289 d = c.ln(Decimal(10))
3294 Decimal = self.decimal.Decimal
3298 d = c.log10(Decimal(10))
3303 Decimal = self.decimal.Decimal
3307 d = c.logb(Decimal(10))
3312 Decimal = self.decimal.Decimal
3316 d = c.logical_and(Decimal(1), Decimal(1))
3318 self.assertEqual(c.logical_and(Decimal(1), 1), d)
3319 self.assertEqual(c.logical_and(1, Decimal(1)), d)
3324 Decimal = self.decimal.Decimal
3328 d = c.logical_invert(Decimal(1000))
3333 Decimal = self.decimal.Decimal
3337 d = c.logical_or(Decimal(1), Decimal(1))
3339 self.assertEqual(c.logical_or(Decimal(1), 1), d)
3340 self.assertEqual(c.logical_or(1, Decimal(1)), d)
3345 Decimal = self.decimal.Decimal
3349 d = c.logical_xor(Decimal(1), Decimal(1))
3351 self.assertEqual(c.logical_xor(Decimal(1), 1), d)
3352 self.assertEqual(c.logical_xor(1, Decimal(1)), d)
3357 Decimal = self.decimal.Decimal
3361 d = c.max(Decimal(1), Decimal(2))
3363 self.assertEqual(c.max(Decimal(1), 2), d)
3364 self.assertEqual(c.max(1, Decimal(2)), d)
3369 Decimal = self.decimal.Decimal
3373 d = c.max_mag(Decimal(1), Decimal(2))
3375 self.assertEqual(c.max_mag(Decimal(1), 2), d)
3376 self.assertEqual(c.max_mag(1, Decimal(2)), d)
3381 Decimal = self.decimal.Decimal
3385 d = c.min(Decimal(1), Decimal(2))
3387 self.assertEqual(c.min(Decimal(1), 2), d)
3388 self.assertEqual(c.min(1, Decimal(2)), d)
3393 Decimal = self.decimal.Decimal
3397 d = c.min_mag(Decimal(1), Decimal(2))
3399 self.assertEqual(c.min_mag(Decimal(1), 2), d)
3400 self.assertEqual(c.min_mag(1, Decimal(2)), d)
3405 Decimal = self.decimal.Decimal
3409 d = c.minus(Decimal(10))
3414 Decimal = self.decimal.Decimal
3418 d = c.multiply(Decimal(1), Decimal(2))
3420 self.assertEqual(c.multiply(Decimal(1), 2), d)
3421 self.assertEqual(c.multiply(1, Decimal(2)), d)
3426 Decimal = self.decimal.Decimal
3430 d = c.next_minus(Decimal(10))
3435 Decimal = self.decimal.Decimal
3439 d = c.next_plus(Decimal(10))
3444 Decimal = self.decimal.Decimal
3448 d = c.next_toward(Decimal(1), Decimal(2))
3450 self.assertEqual(c.next_toward(Decimal(1), 2), d)
3451 self.assertEqual(c.next_toward(1, Decimal(2)), d)
3456 Decimal = self.decimal.Decimal
3460 d = c.normalize(Decimal(10))
3465 Decimal = self.decimal.Decimal
3469 self.assertEqual(c.number_class(123), c.number_class(Decimal(123)))
3470 self.assertEqual(c.number_class(0), c.number_class(Decimal(0)))
3471 self.assertEqual(c.number_class(-45), c.number_class(Decimal(-45)))
3474 Decimal = self.decimal.Decimal
3478 d = c.plus(Decimal(10))
3483 Decimal = self.decimal.Decimal
3487 d = c.power(Decimal(1), Decimal(4))
3489 self.assertEqual(c.power(Decimal(1), 4), d)
3490 self.assertEqual(c.power(1, Decimal(4)), d)
3491 self.assertEqual(c.power(Decimal(1), Decimal(4)), d)
3497 Decimal = self.decimal.Decimal
3501 d = c.quantize(Decimal(1), Decimal(2))
3503 self.assertEqual(c.quantize(Decimal(1), 2), d)
3504 self.assertEqual(c.quantize(1, Decimal(2)), d)
3509 Decimal = self.decimal.Decimal
3513 d = c.remainder(Decimal(1), Decimal(2))
3515 self.assertEqual(c.remainder(Decimal(1), 2), d)
3516 self.assertEqual(c.remainder(1, Decimal(2)), d)
3521 Decimal = self.decimal.Decimal
3525 d = c.remainder_near(Decimal(1), Decimal(2))
3527 self.assertEqual(c.remainder_near(Decimal(1), 2), d)
3528 self.assertEqual(c.remainder_near(1, Decimal(2)), d)
3533 Decimal = self.decimal.Decimal
3537 d = c.rotate(Decimal(1), Decimal(2))
3539 self.assertEqual(c.rotate(Decimal(1), 2), d)
3540 self.assertEqual(c.rotate(1, Decimal(2)), d)
3545 Decimal = self.decimal.Decimal
3549 d = c.sqrt(Decimal(10))
3554 Decimal = self.decimal.Decimal
3558 d = c.same_quantum(Decimal(1), Decimal(2))
3560 self.assertEqual(c.same_quantum(Decimal(1), 2), d)
3561 self.assertEqual(c.same_quantum(1, Decimal(2)), d)
3566 Decimal = self.decimal.Decimal
3570 d = c.scaleb(Decimal(1), Decimal(2))
3572 self.assertEqual(c.scaleb(Decimal(1), 2), d)
3573 self.assertEqual(c.scaleb(1, Decimal(2)), d)
3578 Decimal = self.decimal.Decimal
3582 d = c.shift(Decimal(1), Decimal(2))
3584 self.assertEqual(c.shift(Decimal(1), 2), d)
3585 self.assertEqual(c.shift(1, Decimal(2)), d)
3590 Decimal = self.decimal.Decimal
3594 d = c.subtract(Decimal(1), Decimal(2))
3596 self.assertEqual(c.subtract(Decimal(1), 2), d)
3597 self.assertEqual(c.subtract(1, Decimal(2)), d)
3602 Decimal = self.decimal.Decimal
3606 d = c.to_eng_string(Decimal(10))
3611 Decimal = self.decimal.Decimal
3615 d = c.to_sci_string(Decimal(10))
3620 Decimal = self.decimal.Decimal
3624 d = c.to_integral_exact(Decimal(10))
3629 Decimal = self.decimal.Decimal
3633 d = c.to_integral_value(Decimal(10))
3713 Decimal = self.decimal.Decimal
3734 self.assertRaises(Overflow, c2.power, Decimal('3.4e200'), 2)
3813 Decimal = self.decimal.Decimal
3834 (context._apply, [Decimal("100E-425000010")]),
3835 (context.sqrt, [Decimal(2)]),
3836 (context.add, [Decimal("1.23456789"), Decimal("9.87654321")]),
3837 (context.multiply, [Decimal("1.23456789"), Decimal("9.87654321")]),
3838 (context.subtract, [Decimal("1.23456789"), Decimal("9.87654321")]),
3916 Decimal = self.decimal.Decimal
3926 self.assertEqual(Decimal(7.5), 7.5)
3935 x = Decimal.from_float(7.5)
3952 self.assertRaises(FloatOperation, Decimal, 7.5)
3961 x = Decimal.from_float(7.5)
3969 Decimal = self.decimal.Decimal
3983 small_d = Decimal('0.25')
3984 big_d = Decimal('3.0')
3988 zero_d = Decimal('0.0')
3989 neg_zero_d = Decimal('-0.0')
3993 inf_d = Decimal('Infinity')
3994 neg_inf_d = Decimal('-Infinity')
4021 assert_attr(Decimal('0.1'), 0.1, '__ne__', c, None)
4026 assert_attr(Decimal('NaN'), float('nan'), '__ne__', c, None)
4030 s = set([100.0, Decimal('100.0')])
4036 self.assertRaises(signal, sorted, [1.0, Decimal('10.0')])
4038 s = sorted([10.0, Decimal('10.0')])
4042 b = 10.0 in [Decimal('10.0'), 1.0]
4046 b = 10.0 in {Decimal('10.0'):'a', 1.0:'b'}
4060 Decimal = self.decimal.Decimal
4236 Decimal = decimal.Decimal
4283 self.assertRaises(InvalidOperation, c.quantize, Decimal('9e2'), 0)
4289 self.assertEqual(c.plus(Decimal('9.9')), 9)
4295 x = c.add(Decimal('1e-99'), Decimal('2.234e-2000'))
4296 self.assertEqual(x, Decimal('0.0'))
4304 self.assertRaises(Overflow, c.add, Decimal('1e99'), Decimal('2.234e2000'))
4320 x = c.plus(Decimal('1e99'))
4372 x = [s for s in dir(C.Decimal(9)) if '__' in s or not s.startswith('_')]
4373 y = [s for s in dir(C.Decimal(9)) if '__' in s or not s.startswith('_')]
4379 Decimal = self.decimal.Decimal
4381 self.assertEqual(Decimal('1234e9999').adjusted(), 10002)
4383 self.assertEqual(Decimal('nan').adjusted(), 0)
4384 self.assertEqual(Decimal('inf').adjusted(), 0)
4387 Decimal = self.decimal.Decimal
4390 x = Decimal(9).canonical()
4394 x = c.canonical(Decimal(9))
4417 Decimal = self.decimal.Decimal
4426 self.assertEqual(abs(Decimal("-10")), 10)
4428 self.assertEqual(Decimal("7") + 1, 8)
4430 self.assertEqual(Decimal("10") / 5, 2)
4432 self.assertEqual(Decimal("10") // 7, 1)
4434 self.assertEqual(Decimal("1.2").fma(Decimal("0.01"), 1), 1)
4435 self.assertIs(Decimal("NaN").fma(7, 1).is_nan(), True)
4437 self.assertEqual(pow(Decimal(10), 2, 7), 2)
4439 self.assertEqual(Decimal("1.01").exp(), 3)
4441 self.assertIs(Decimal("0.01").is_normal(), False)
4443 self.assertIs(Decimal("0.01").is_subnormal(), True)
4445 self.assertEqual(Decimal("20").ln(), 3)
4447 self.assertEqual(Decimal("20").log10(), 1)
4449 self.assertEqual(Decimal("580").logb(), 2)
4451 self.assertEqual(Decimal("10").logical_invert(), 1)
4453 self.assertEqual(-Decimal("-10"), 10)
4455 self.assertEqual(Decimal("2") * 4, 8)
4457 self.assertEqual(Decimal("10").next_minus(), 9)
4459 self.assertEqual(Decimal("10").next_plus(), Decimal('2E+1'))
4461 self.assertEqual(Decimal("-10").normalize(), Decimal('-1E+1'))
4463 self.assertEqual(Decimal("10").number_class(), '+Normal')
4465 self.assertEqual(+Decimal("-1"), -1)
4467 self.assertEqual(Decimal("10") % 7, 3)
4469 self.assertEqual(Decimal("10") - 7, 3)
4471 self.assertEqual(Decimal("1.12345").to_integral_exact(), 1)
4474 self.assertTrue(Decimal("1").is_canonical())
4475 self.assertTrue(Decimal("1").is_finite())
4476 self.assertTrue(Decimal("1").is_finite())
4477 self.assertTrue(Decimal("snan").is_snan())
4478 self.assertTrue(Decimal("-1").is_signed())
4479 self.assertTrue(Decimal("0").is_zero())
4480 self.assertTrue(Decimal("0").is_zero())
4486 y = -Decimal(x)
4494 z = y.copy_sign(Decimal(1))
4498 Decimal = self.decimal.Decimal
4504 q, r = divmod(Decimal("10912837129"), 1001)
4505 self.assertEqual(q, Decimal('10901935'))
4506 self.assertEqual(r, Decimal('194'))
4508 q, r = divmod(Decimal("NaN"), 7)
4512 q, r = divmod(Decimal("NaN"), 7)
4517 q, r = divmod(Decimal("inf"), Decimal("inf"))
4522 q, r = divmod(Decimal("inf"), 101)
4527 q, r = divmod(Decimal(0), 0)
4533 q, r = divmod(Decimal(11), 0)
4539 Decimal = self.decimal.Decimal
4547 self.assertEqual(Decimal("1.0") ** 100, Decimal('1.00'))
4555 self.assertEqual(Decimal(10000) ** Decimal("0.5"), Decimal('inf'))
4559 Decimal = self.decimal.Decimal
4568 x = Decimal(99).quantize(Decimal("1e1"))
4572 Decimal = self.decimal.Decimal
4576 self.assertEqual(Decimal("1").radix(), 10)
4580 Decimal = self.decimal.Decimal
4584 self.assertIs(getattr(Decimal("1"), attr)("xyz"), NotImplemented)
4587 # Python3 behavior: round() returns Decimal
4588 Decimal = self.decimal.Decimal
4594 self.assertEqual(str(Decimal("9.99").__round__()), "10")
4595 self.assertEqual(str(Decimal("9.99e-5").__round__()), "0")
4596 self.assertEqual(str(Decimal("1.23456789").__round__(5)), "1.23457")
4597 self.assertEqual(str(Decimal("1.2345").__round__(10)), "1.2345000000")
4598 self.assertEqual(str(Decimal("1.2345").__round__(-10)), "0E+10")
4600 self.assertRaises(TypeError, Decimal("1.23").__round__, "5")
4601 self.assertRaises(TypeError, Decimal("1.23").__round__, 5, 8)
4608 Decimal = self.decimal.Decimal
4613 x = Decimal(1221**1271) / 10**3923
4651 # triples giving a format, a Decimal, and the expected result
4652 Decimal = P.Decimal
4669 self.assertEqual(format(Decimal(d), fmt), result)
4676 Decimal = P.Decimal
4681 x = Decimal(2**16) ** Decimal("-0.5")
4682 self.assertEqual(x, Decimal('0.00390625'))
4684 x = Decimal(2**16) ** Decimal("-0.6")
4685 self.assertEqual(x, Decimal('0.0012885819'))
4687 x = Decimal("256e7") ** Decimal("-0.5")
4689 x = Decimal(152587890625) ** Decimal('-0.0625')
4690 self.assertEqual(x, Decimal("0.2"))
4692 x = Decimal("152587890625e7") ** Decimal('-0.0625')
4694 x = Decimal(5**2659) ** Decimal('-0.0625')
4697 x = Decimal("152587890625") ** Decimal('-0.5')
4699 x = Decimal(2**578) ** Decimal("-0.5")
4703 Decimal = P.Decimal
4711 d1 = Decimal('-25e55')
4712 b1 = Decimal('-25e55')
4713 d2 = Decimal('33e+33')
4714 b2 = Decimal('33e+33')
4731 Decimal(d1)
4781 Decimal = P.Decimal
4783 d = Decimal(45)
4784 e = Decimal(d)
4790 Decimal = P.Decimal
4794 x = Decimal("NaN")._rescale(3, ROUND_UP)
4799 Decimal = P.Decimal
4801 self.assertRaises(ValueError, Decimal("3.1234")._round, 0, ROUND_UP)
4894 Decimal = C.Decimal
4905 y = Decimal(a) ** Decimal(b)
4909 self.assertRaises(TypeError, C.Decimal, 9, "xyz")
4913 Decimal = C.Decimal
4919 self.assertRaises(InvalidOperation, Decimal,
5155 Decimal = C.Decimal
5164 self.assertRaises(InvalidOperation, Decimal("1.23").__round__,
5166 self.assertRaises(InvalidOperation, Decimal("1.23").__round__,
5168 self.assertRaises(InvalidOperation, Decimal("1").__round__,
5170 self.assertRaises(C.InvalidOperation, Decimal("1").__round__,
5172 self.assertRaises(OverflowError, Decimal("1.23").__round__,
5174 self.assertRaises(OverflowError, Decimal("1.23").__round__,
5179 Decimal = C.Decimal
5182 self.assertRaises(TypeError, Decimal(1).__format__, "=10.10", [], 9)
5183 self.assertRaises(TypeError, Decimal(1).__format__, "=10.10", 9)
5184 self.assertRaises(TypeError, Decimal(1).__format__, [])
5186 self.assertRaises(ValueError, Decimal(1).__format__, "<>=10.10")
5188 self.assertRaises(ValueError, Decimal("1.23456789").__format__,
5192 Decimal = C.Decimal
5196 x = Decimal(10)
5213 x = Decimal("99999999999999999999999999.9").to_integral_value(ROUND_UP)
5214 self.assertEqual(x, Decimal('100000000000000000000000000'))
5216 x = Decimal("99999999999999999999999999.9").to_integral_exact(ROUND_UP)
5217 self.assertEqual(x, Decimal('100000000000000000000000000'))
5220 self.assertRaises(Inexact, Decimal("999.9").to_integral_exact, ROUND_UP)
5224 Decimal = C.Decimal
5230 self.assertEqual(Decimal('9.99e10').to_eng_string(), '99.9E+9')
5232 self.assertRaises(TypeError, pow, Decimal(1), 2, "3")
5233 self.assertRaises(TypeError, Decimal(9).number_class, "x", "y")
5234 self.assertRaises(TypeError, Decimal(9).same_quantum, 3, "x", "y")
5238 Decimal("1.23456789").quantize, Decimal('1e-100000'), []
5242 Decimal("1.23456789").quantize, Decimal('1e-100000'), getcontext()
5246 Decimal("1.23456789").quantize, Decimal('1e-100000'), 10
5250 Decimal("1.23456789").quantize, Decimal('1e-100000'), ROUND_UP, 1000
5257 self.assertRaises(TypeError, c.copy_sign, Decimal(1), "x", "y")
5263 self.assertEqual(str(c.canonical(Decimal(200))), '200')
5267 self.assertRaises(DivisionByZero, Decimal(9).__divmod__, 0)
5273 self.assertRaises(InvalidOperation, Decimal(9).__divmod__, 0)
5279 self.assertRaises(InvalidOperation, pow, Decimal(1000), 1, 501)
5282 Decimal = C.Decimal
5285 x = Decimal("10001111111")
5472 Decimal = C.Decimal
5483 return Decimal(x).__format__(fmt, override)
5509 Decimal = C.Decimal
5519 self.assertRaises(InvalidOperation, Decimal, x)
5522 self.assertRaises(InvalidOperation, Decimal, x)
5526 self.assertRaises(InvalidOperation, Decimal, x)
5530 self.assertRaises(InvalidOperation, Decimal, x)
5533 Decimal = C.Decimal
5549 self.assertRaises(InvalidOperation, Decimal, x)
5553 self.assertRaises(InvalidOperation, Decimal, x)
5558 self.assertRaises(InvalidOperation, Decimal, x)
5562 self.assertRaises(InvalidOperation, Decimal, x)
5567 self.assertRaises(OverflowError, Decimal, x)
5571 self.assertRaises(OverflowError, Decimal, x)
5575 self.assertEqual(str(Decimal(x)), '-sNaN')
5577 self.assertEqual(str(Decimal(x)), '-sNaN')
5579 self.assertEqual(str(Decimal(x)), '-sNaN1')
5582 Decimal = C.Decimal
5585 self.assertGreater(Decimal(0).__sizeof__(), 0)
5587 x = Decimal(10**(19*24)).__sizeof__()
5588 y = Decimal(10**(19*25)).__sizeof__()
5591 x = Decimal(10**(9*24)).__sizeof__()
5592 y = Decimal(10**(9*25)).__sizeof__()
5596 Decimal = C.Decimal
5620 self.assertEqual(Decimal.from_float(cls(101.1)),
5621 Decimal.from_float(101.1))
5643 Decimal = C.Decimal
5651 self.assertEqual(Decimal(0).exp(), 1)
5652 self.assertEqual(Decimal(1).ln(), 0)
5653 self.assertEqual(Decimal(1).log10(), 0)
5654 self.assertEqual(Decimal(10**2).log10(), 2)
5655 self.assertEqual(Decimal(10**223).log10(), 223)
5656 self.assertEqual(Decimal(10**19).logb(), 19)
5657 self.assertEqual(Decimal(4).sqrt(), 2)
5658 self.assertEqual(Decimal("40E9").sqrt(), Decimal('2.0E+5'))
5659 self.assertEqual(divmod(Decimal(10), 3), (3, 1))
5660 self.assertEqual(Decimal(10) // 3, 3)
5661 self.assertEqual(Decimal(4) / 2, 2)
5662 self.assertEqual(Decimal(400) ** -1, Decimal('0.0025'))
5676 if (attr == 'Decimal' or attr == 'Context' or
5704 pdict = {C: {'other': C.Decimal(1),
5705 'third': C.Decimal(1),
5706 'x': C.Decimal(1),
5707 'y': C.Decimal(1),
5708 'z': C.Decimal(1),
5709 'a': C.Decimal(1),
5710 'b': C.Decimal(1),
5711 'c': C.Decimal(1),
5712 'exp': C.Decimal(1),
5713 'modulo': C.Decimal(1),
5718 P: {'other': P.Decimal(1),
5719 'third': P.Decimal(1),
5720 'a': P.Decimal(1),
5721 'b': P.Decimal(1),
5722 'c': P.Decimal(1),
5723 'exp': P.Decimal(1),
5724 'modulo': P.Decimal(1),
5778 if ty == 'Decimal':
5798 doit('Decimal')