Lines Matching full:decimal
11 These are the test cases for the Decimal module.
14 the Decimal arithmetic using the tests provided by Mike Cowlishaw. The latter
19 http://speleotrove.com/decimal/dectest.zip
63 C = import_fresh_module('decimal', fresh=['_decimal'])
64 P = import_fresh_module('decimal', blocked=['_decimal'])
65 import decimal as orig_sys_decimal
67 # fractions module must import the correct decimal module.
69 sys.modules['decimal'] = P
71 sys.modules['decimal'] = C
73 sys.modules['decimal'] = orig_sys_decimal
147 """Class which tests the Decimal class against the IBM test cases."""
150 self.context = self.decimal.Context()
151 self.readcontext = self.decimal.Context()
166 # Decimal behaves differently from decNumber for these testcases so these
192 if self.decimal == C:
212 # Name adapter to be able to change the Decimal and Context
263 self.ErrorNames = {'clamped' : self.decimal.Clamped,
264 'conversion_syntax' : self.decimal.InvalidOperation,
265 'division_by_zero' : self.decimal.DivisionByZero,
266 'division_impossible' : self.decimal.InvalidOperation,
267 'division_undefined' : self.decimal.InvalidOperation,
268 'inexact' : self.decimal.Inexact,
269 'invalid_context' : self.decimal.InvalidOperation,
270 'invalid_operation' : self.decimal.InvalidOperation,
271 'overflow' : self.decimal.Overflow,
272 'rounded' : self.decimal.Rounded,
273 'subnormal' : self.decimal.Subnormal,
274 'underflow' : self.decimal.Underflow}
277 # Decimal instance.
296 if self.decimal == C and self.decimal.MAX_EMAX == 425000000:
302 return self.decimal.Decimal(v, context)
314 except self.decimal.DecimalException as exception:
369 raise self.decimal.InvalidOperation
388 for exception in Signals[self.decimal]:
410 except Signals[self.decimal] as e:
430 except Signals[self.decimal] as e:
438 ordered_errors = [e for e in OrderedSignals[self.decimal] if e in theirexceptions]
445 except Signals[self.decimal] as e:
461 except Signals[self.decimal] as error:
479 return [e for e in Signals[self.decimal] if self.context.flags[e]]
482 if self.decimal == C and self.decimal.MAX_PREC == 425000000:
489 if self.decimal == C and self.decimal.MAX_PREC == 425000000:
494 if self.decimal == C and self.decimal.MAX_PREC == 425000000:
502 decimal = C variable in CIBMTestCases
504 decimal = P variable in PyIBMTestCases
506 # The following classes test the behaviour of Decimal according to PEP 327
509 '''Unit tests for Explicit Construction cases of Decimal.'''
512 Decimal = self.decimal.Decimal
513 self.assertEqual(Decimal(), Decimal("0"))
516 Decimal = self.decimal.Decimal
517 self.assertRaises(TypeError, Decimal, None)
520 Decimal = self.decimal.Decimal
523 d = Decimal(45)
527 d = Decimal(500000123)
531 d = Decimal(-45)
535 d = Decimal(0)
543 d = Decimal(i)
547 Decimal = self.decimal.Decimal
548 InvalidOperation = self.decimal.InvalidOperation
549 localcontext = self.decimal.localcontext
552 self.assertEqual(str(Decimal('')), 'NaN')
555 self.assertEqual(str(Decimal('45')), '45')
558 self.assertEqual(str(Decimal('45.34')), '45.34')
561 self.assertEqual(str(Decimal('45e2')), '4.5E+3')
564 self.assertEqual(str(Decimal('ugly')), 'NaN')
567 self.assertEqual(str(Decimal('1.3E4 \n')), '1.3E+4')
568 self.assertEqual(str(Decimal(' -7.89')), '-7.89')
569 self.assertEqual(str(Decimal(" 3.45679 ")), '3.45679')
572 self.assertEqual(str(Decimal('1_3.3e4_0')), '1.33E+41')
573 self.assertEqual(str(Decimal('1_0_0_0')), '1000')
578 self.assertEqual(str(Decimal(lead + '9.311E+28' + trail)),
584 self.assertRaises(InvalidOperation, Decimal, "xyz")
586 self.assertRaises(TypeError, Decimal, "1234", "x", "y")
589 self.assertRaises(InvalidOperation, Decimal, "1\u00a02\u00a03")
590 self.assertRaises(InvalidOperation, Decimal, "\u00a01\u00a02\u00a0")
593 self.assertRaises(InvalidOperation, Decimal, "\u00a0")
594 self.assertRaises(InvalidOperation, Decimal, "\u00a0\u00a0")
597 self.assertRaises(InvalidOperation, Decimal, "12\u00003")
600 self.assertRaises(InvalidOperation, Decimal, "1_2_\u00003")
607 Decimal = self.decimal.Decimal
608 context = self.decimal.Context()
611 self.assertEqual(str(Decimal(s)), '9.999999')
615 Decimal = self.decimal.Decimal
618 d = Decimal( (0, (0,), 0) )
622 d = Decimal( (1, (4, 5), 0) )
626 d = Decimal( (0, (4, 5, 3, 4), -2) )
630 d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
634 d = Decimal( (0, (), "F") )
638 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1)) )
641 self.assertRaises(ValueError, Decimal, (8, (4, 3, 4, 9, 1), 2) )
642 self.assertRaises(ValueError, Decimal, (0., (4, 3, 4, 9, 1), 2) )
643 self.assertRaises(ValueError, Decimal, (Decimal(1), (4, 3, 4, 9, 1), 2))
646 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), 'wrong!') )
647 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), 0.) )
648 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), '1') )
651 self.assertRaises(ValueError, Decimal, (1, "xyz", 2) )
652 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, None, 1), 2) )
653 self.assertRaises(ValueError, Decimal, (1, (4, -3, 4, 9, 1), 2) )
654 self.assertRaises(ValueError, Decimal, (1, (4, 10, 4, 9, 1), 2) )
655 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 'a', 1), 2) )
658 Decimal = self.decimal.Decimal
660 d = Decimal([0, [0], 0])
663 d = Decimal([1, [4, 3, 4, 9, 1, 3, 5, 3, 4], -25])
666 d = Decimal([1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25])
669 d = Decimal((1, [4, 3, 4, 9, 1, 3, 5, 3, 4], -25))
673 Decimal = self.decimal.Decimal
675 self.assertIs(bool(Decimal(0)), False)
676 self.assertIs(bool(Decimal(1)), True)
677 self.assertEqual(Decimal(False), Decimal(0))
678 self.assertEqual(Decimal(True), Decimal(1))
681 Decimal = self.decimal.Decimal
684 d = Decimal(45)
685 e = Decimal(d)
689 d = Decimal(500000123)
690 e = Decimal(d)
694 d = Decimal(-45)
695 e = Decimal(d)
699 d = Decimal(0)
700 e = Decimal(d)
706 Decimal = self.decimal.Decimal
708 r = Decimal(0.1)
709 self.assertEqual(type(r), Decimal)
712 self.assertTrue(Decimal(float('nan')).is_qnan())
713 self.assertTrue(Decimal(float('inf')).is_infinite())
714 self.assertTrue(Decimal(float('-inf')).is_infinite())
715 self.assertEqual(str(Decimal(float('nan'))),
716 str(Decimal('NaN')))
717 self.assertEqual(str(Decimal(float('inf'))),
718 str(Decimal('Infinity')))
719 self.assertEqual(str(Decimal(float('-inf'))),
720 str(Decimal('-Infinity')))
721 self.assertEqual(str(Decimal(float('-0.0'))),
722 str(Decimal('-0')))
725 self.assertEqual(x, float(Decimal(x))) # roundtrip
728 Decimal = self.decimal.Decimal
729 InvalidOperation = self.decimal.InvalidOperation
730 Rounded = self.decimal.Rounded
732 nc = copy.copy(self.decimal.getcontext())
736 d = Decimal()
746 self.assertIsInstance(d, Decimal)
751 d = Decimal('456789')
761 d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
766 # from Decimal
767 prevdec = Decimal(500000123)
768 d = Decimal(prevdec)
780 self.assertTrue(isinstance(d, Decimal))
806 Decimal('NaN12345'))
813 self.assertEqual(str(nc.create_decimal(Decimal('NaN12345'))), 'NaN')
818 Decimal = self.decimal.Decimal
820 nc = self.decimal.Context()
822 self.assertEqual(type(r), Decimal)
841 Decimal = self.decimal.Decimal
849 self.assertEqual(str(Decimal(input)), expected)
852 decimal = C variable in CExplicitConstructionTest
854 decimal = P variable in PyExplicitConstructionTest
857 '''Unit tests for Implicit Construction cases of Decimal.'''
860 Decimal = self.decimal.Decimal
861 self.assertRaises(TypeError, eval, 'Decimal(5) + None', locals())
864 Decimal = self.decimal.Decimal
867 self.assertEqual(str(Decimal(5) + 45), '50')
869 self.assertEqual(Decimal(5) + 123456789000, Decimal(123456789000))
872 Decimal = self.decimal.Decimal
873 self.assertRaises(TypeError, eval, 'Decimal(5) + "3"', locals())
876 Decimal = self.decimal.Decimal
877 self.assertRaises(TypeError, eval, 'Decimal(5) + 2.2', locals())
880 Decimal = self.decimal.Decimal
881 self.assertEqual(Decimal(5) + Decimal(45), Decimal(50))
884 Decimal = self.decimal.Decimal
905 self.assertEqual(divmod(E(), Decimal(10)), 'divmod 10')
906 self.assertEqual(divmod(Decimal(10), E()), '10 rdivmod')
907 self.assertEqual(eval('Decimal(10) < E()'), 'gt 10')
908 self.assertEqual(eval('Decimal(10) > E()'), 'lt 10')
909 self.assertEqual(eval('Decimal(10) <= E()'), 'ge 10')
910 self.assertEqual(eval('Decimal(10) >= E()'), 'le 10')
911 self.assertEqual(eval('Decimal(10) == E()'), 'eq 10')
912 self.assertEqual(eval('Decimal(10) != E()'), 'ne 10')
928 self.assertEqual(eval('E()' + sym + 'Decimal(10)'),
930 self.assertEqual(eval('Decimal(10)' + sym + 'E()'),
934 decimal = C variable in CImplicitConstructionTest
936 decimal = P variable in PyImplicitConstructionTest
941 Decimal = self.decimal.Decimal
943 # triples giving a format, a Decimal, and the expected result
979 ('.0f', '0', '0'), # no decimal point
1094 self.assertEqual(format(Decimal(d), fmt), result)
1097 self.assertRaises(TypeError, Decimal(1).__format__, b'-020')
1100 Decimal = self.decimal.Decimal
1108 return ''.join([chr(x) for x in lst]) if self.decimal == C else lst
1111 if self.decimal == C:
1112 return Decimal(x).__format__(fmt, override)
1114 return Decimal(x).__format__(fmt, _localeconv=override)
1147 self.assertEqual(get_fmt(Decimal('12.7'), en_US), '12.7')
1148 self.assertEqual(get_fmt(Decimal('12.7'), fr_FR), '12,7')
1149 self.assertEqual(get_fmt(Decimal('12.7'), ru_RU), '12,7')
1150 self.assertEqual(get_fmt(Decimal('12.7'), crazy), '1-2&7')
1184 # wide char separator and decimal point
1185 self.assertEqual(get_fmt(Decimal('-1.5'), dotsep_wide, '020n'),
1190 # locale with wide char separator and decimal point
1191 Decimal = self.decimal.Decimal
1196 self.skipTest('inappropriate decimal point separator '
1202 self.assertEqual(format(Decimal('100000000.123'), 'n'),
1206 class A(self.decimal.Decimal):
1210 self.assertEqual(self.decimal.Decimal, a.a_type)
1213 self.assertEqual(self.decimal.Decimal, a.a_type)
1216 decimal = C variable in CFormatTest
1218 decimal = P variable in PyFormatTest
1224 Decimal = self.decimal.Decimal
1226 d1 = Decimal('-11.1')
1227 d2 = Decimal('22.2')
1230 self.assertEqual(d1+d2, Decimal('11.1'))
1231 self.assertEqual(d2+d1, Decimal('11.1'))
1235 self.assertEqual(c, Decimal('-6.1'))
1240 self.assertEqual(c, Decimal('-6.1'))
1243 #inline with decimal
1245 self.assertEqual(d1, Decimal('11.1'))
1249 self.assertEqual(d1, Decimal('16.1'))
1252 Decimal = self.decimal.Decimal
1254 d1 = Decimal('-11.1')
1255 d2 = Decimal('22.2')
1258 self.assertEqual(d1-d2, Decimal('-33.3'))
1259 self.assertEqual(d2-d1, Decimal('33.3'))
1263 self.assertEqual(c, Decimal('-16.1'))
1268 self.assertEqual(c, Decimal('16.1'))
1271 #inline with decimal
1273 self.assertEqual(d1, Decimal('-33.3'))
1277 self.assertEqual(d1, Decimal('-38.3'))
1280 Decimal = self.decimal.Decimal
1282 d1 = Decimal('-5')
1283 d2 = Decimal('3')
1286 self.assertEqual(d1*d2, Decimal('-15'))
1287 self.assertEqual(d2*d1, Decimal('-15'))
1291 self.assertEqual(c, Decimal('-25'))
1296 self.assertEqual(c, Decimal('-25'))
1299 #inline with decimal
1301 self.assertEqual(d1, Decimal('-15'))
1305 self.assertEqual(d1, Decimal('-75'))
1308 Decimal = self.decimal.Decimal
1310 d1 = Decimal('-5')
1311 d2 = Decimal('2')
1314 self.assertEqual(d1/d2, Decimal('-2.5'))
1315 self.assertEqual(d2/d1, Decimal('-0.4'))
1319 self.assertEqual(c, Decimal('-1.25'))
1324 self.assertEqual(c, Decimal('-0.8'))
1327 #inline with decimal
1329 self.assertEqual(d1, Decimal('-2.5'))
1333 self.assertEqual(d1, Decimal('-0.625'))
1336 Decimal = self.decimal.Decimal
1338 d1 = Decimal('5')
1339 d2 = Decimal('2')
1342 self.assertEqual(d1//d2, Decimal('2'))
1343 self.assertEqual(d2//d1, Decimal('0'))
1347 self.assertEqual(c, Decimal('1'))
1352 self.assertEqual(c, Decimal('1'))
1355 #inline with decimal
1357 self.assertEqual(d1, Decimal('2'))
1361 self.assertEqual(d1, Decimal('1'))
1364 Decimal = self.decimal.Decimal
1366 d1 = Decimal('5')
1367 d2 = Decimal('2')
1370 self.assertEqual(d1**d2, Decimal('25'))
1371 self.assertEqual(d2**d1, Decimal('32'))
1375 self.assertEqual(c, Decimal('625'))
1380 self.assertEqual(c, Decimal('16807'))
1383 #inline with decimal
1385 self.assertEqual(d1, Decimal('25'))
1389 self.assertEqual(d1, Decimal('390625'))
1392 Decimal = self.decimal.Decimal
1394 d1 = Decimal('5')
1395 d2 = Decimal('2')
1398 self.assertEqual(d1%d2, Decimal('1'))
1399 self.assertEqual(d2%d1, Decimal('2'))
1403 self.assertEqual(c, Decimal('1'))
1408 self.assertEqual(c, Decimal('2'))
1411 #inline with decimal
1413 self.assertEqual(d1, Decimal('1'))
1417 self.assertEqual(d1, Decimal('1'))
1420 Decimal = self.decimal.Decimal
1422 d1 = Decimal('5')
1423 d2 = Decimal('2')
1427 self.assertEqual(p, Decimal('2'))
1428 self.assertEqual(q, Decimal('1'))
1434 self.assertEqual(p, Decimal('1'))
1435 self.assertEqual(q, Decimal('1'))
1441 self.assertEqual(p, Decimal('1'))
1442 self.assertEqual(q, Decimal('2'))
1447 Decimal = self.decimal.Decimal
1449 self.assertEqual(+Decimal(45), Decimal(+45)) # +
1450 self.assertEqual(-Decimal(45), Decimal(-45)) # -
1451 self.assertEqual(abs(Decimal(45)), abs(Decimal(-45))) # abs
1461 Decimal = self.decimal.Decimal
1462 InvalidOperation = self.decimal.InvalidOperation
1463 localcontext = self.decimal.localcontext
1465 n = Decimal('NaN')
1466 s = Decimal('sNaN')
1467 i = Decimal('Inf')
1468 f = Decimal('2')
1509 Decimal = self.decimal.Decimal
1511 d = Decimal(1).copy_sign(Decimal(-2))
1512 self.assertEqual(Decimal(1).copy_sign(-2), d)
1513 self.assertRaises(TypeError, Decimal(1).copy_sign, '-2')
1516 decimal = C variable in CArithmeticOperatorsTest
1518 decimal = P variable in PyArithmeticOperatorsTest
1523 Decimal = cls.decimal.Decimal
1524 InvalidOperation = cls.decimal.InvalidOperation
1525 DivisionByZero = cls.decimal.DivisionByZero
1526 Overflow = cls.decimal.Overflow
1527 Underflow = cls.decimal.Underflow
1528 Inexact = cls.decimal.Inexact
1529 getcontext = cls.decimal.getcontext
1530 localcontext = cls.decimal.localcontext
1532 d1 = Decimal(1)
1533 d3 = Decimal(3)
1547 cls.assertRaises(InvalidOperation, c3.compare, d1, Decimal('sNaN'))
1553 cls.assertEqual(test1, Decimal('0.333333333333333333333333'))
1554 cls.assertEqual(test2, Decimal('0.333333333333333333333333'))
1562 Decimal = cls.decimal.Decimal
1563 InvalidOperation = cls.decimal.InvalidOperation
1564 DivisionByZero = cls.decimal.DivisionByZero
1565 Overflow = cls.decimal.Overflow
1566 Underflow = cls.decimal.Underflow
1567 Inexact = cls.decimal.Inexact
1568 getcontext = cls.decimal.getcontext
1569 localcontext = cls.decimal.localcontext
1571 d1 = Decimal(1)
1572 d3 = Decimal(3)
1581 cls.assertRaises(Overflow, c2.multiply, Decimal('1e425000000'), 999)
1587 cls.assertRaises(Underflow, c3.divide, Decimal('1e-425000000'), 999)
1597 cls.assertEqual(test1, Decimal('0.333333333333333333333333'))
1598 cls.assertEqual(test2, Decimal('0.333333333333333333'))
1606 '''Unit tests for thread local contexts in Decimal.'''
1612 DefaultContext = self.decimal.DefaultContext
1614 if self.decimal == C and not self.decimal.HAVE_THREADS:
1639 for sig in Signals[self.decimal]:
1651 decimal = C variable in CThreadingTest
1654 decimal = P variable in PyThreadingTest
1657 '''Unit tests for Usability cases of Decimal.'''
1661 Decimal = self.decimal.Decimal
1663 da = Decimal('23.42')
1664 db = Decimal('23.42')
1665 dc = Decimal('45')
1677 #a Decimal and an int
1682 #a Decimal and uncomparable
1689 a = list(map(Decimal, range(100)))
1696 Decimal = self.decimal.Decimal
1698 da = Decimal('0.25')
1699 db = Decimal('3.0')
1712 self.assertNotEqual(0.1, Decimal('0.1'))
1715 Decimal = self.decimal.Decimal
1717 da = Decimal('0.25')
1718 db = Decimal('3.0')
1735 D = self.decimal.Decimal
1736 F = fractions[self.decimal].Fraction
1737 Context = self.decimal.Context
1738 localcontext = self.decimal.localcontext
1739 InvalidOperation = self.decimal.InvalidOperation
1777 Decimal = self.decimal.Decimal
1779 d = Decimal('43.24')
1787 Decimal = self.decimal.Decimal
1788 localcontext = self.decimal.localcontext
1797 hashit(Decimal(23))
1798 hashit(Decimal('Infinity'))
1799 hashit(Decimal('-Infinity'))
1800 hashit(Decimal('nan123'))
1801 hashit(Decimal('-NaN'))
1803 test_values = [Decimal(sign*(2**m + n))
1809 Decimal("-1"), # ==> -2
1810 Decimal("-0"), # zeros
1811 Decimal("0.00"),
1812 Decimal("-0.000"),
1813 Decimal("0E10"),
1814 Decimal("-0E12"),
1815 Decimal("10.0"), # negative exponent
1816 Decimal("-23.00000"),
1817 Decimal("1230E100"), # positive exponent
1818 Decimal("-4.5678E50"),
1821 Decimal(2**64 + 2**32 - 1),
1824 Decimal("1.634E100"),
1825 Decimal("90.697E100"),
1826 Decimal("188.83E100"),
1827 Decimal("1652.9E100"),
1828 Decimal("56531E100"),
1835 # check that the hashes of a Decimal float match when they
1841 d = Decimal(s)
1847 x = Decimal("123456789.1")
1861 self.assertEqual(hashit(Decimal(x)), hashit(x))
1864 Decimal = self.decimal.Decimal
1865 self.assertRaises(TypeError, hash, Decimal('sNaN'))
1866 value = Decimal('NaN')
1871 class D(Decimal, H):
1877 Decimal = self.decimal.Decimal
1879 d1 = Decimal('15.32')
1880 d2 = Decimal('28.5')
1890 #between Decimal and int
1897 Decimal = self.decimal.Decimal
1900 self.assertFalse(Decimal(0))
1902 self.assertTrue(Decimal('0.372'))
1906 Decimal = self.decimal.Decimal
1908 d = Decimal('15.32')
1910 self.assertEqual(repr(d), "Decimal('15.32')") # repr
1914 Decimal = self.decimal.Decimal
1916 d1 = Decimal('66')
1917 d2 = Decimal('15.32')
1940 self.assertEqual(math.floor(Decimal(d)), i)
1941 self.assertRaises(ValueError, math.floor, Decimal('-NaN'))
1942 self.assertRaises(ValueError, math.floor, Decimal('sNaN'))
1943 self.assertRaises(ValueError, math.floor, Decimal('NaN123'))
1944 self.assertRaises(OverflowError, math.floor, Decimal('Inf'))
1945 self.assertRaises(OverflowError, math.floor, Decimal('-Inf'))
1960 self.assertEqual(math.ceil(Decimal(d)), i)
1961 self.assertRaises(ValueError, math.ceil, Decimal('-NaN'))
1962 self.assertRaises(ValueError, math.ceil, Decimal('sNaN'))
1963 self.assertRaises(ValueError, math.ceil, Decimal('NaN123'))
1964 self.assertRaises(OverflowError, math.ceil, Decimal('Inf'))
1965 self.assertRaises(OverflowError, math.ceil, Decimal('-Inf'))
1987 self.assertEqual(round(Decimal(d)), i)
1988 self.assertRaises(ValueError, round, Decimal('-NaN'))
1989 self.assertRaises(ValueError, round, Decimal('sNaN'))
1990 self.assertRaises(ValueError, round, Decimal('NaN123'))
1991 self.assertRaises(OverflowError, round, Decimal('Inf'))
1992 self.assertRaises(OverflowError, round, Decimal('-Inf'))
2013 self.assertEqual(str(round(Decimal(d), n)), r)
2016 # Test conversions of decimal NANs to float.
2018 Decimal = self.decimal.Decimal
2020 f = float(Decimal(s))
2026 Decimal = self.decimal.Decimal
2028 d = Decimal(s)
2032 Decimal = self.decimal.Decimal
2035 d = Decimal( (0, (0,), 0) )
2039 d = Decimal( (1, (4, 5), 0) )
2043 d = Decimal( (0, (4, 5, 3, 4), -2) )
2047 d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
2051 Decimal = self.decimal.Decimal
2054 d = Decimal(0)
2058 d = Decimal(-45)
2062 d = Decimal("-4.34913534E-17")
2065 # The '0' coefficient is implementation specific to decimal.py.
2067 d = Decimal("Infinity")
2071 d = Decimal( (0, (0, 0, 4, 0, 5, 3, 4), -2) )
2073 d = Decimal( (1, (0, 0, 0), 37) )
2075 d = Decimal( (1, (), 37) )
2079 d = Decimal( (0, (0, 0, 4, 0, 5, 3, 4), 'n') )
2081 d = Decimal( (1, (0, 0, 0), 'N') )
2083 d = Decimal( (1, (), 'n') )
2086 # For infinities, decimal.py has always silently accepted any
2088 d = Decimal( (0, (0,), 'F') )
2090 d = Decimal( (0, (4, 5, 3, 4), 'F') )
2092 d = Decimal( (1, (0, 2, 7, 1), 'F') )
2096 Decimal = self.decimal.Decimal
2100 Decimal.as_integer_ratio, Decimal('inf'))
2102 Decimal.as_integer_ratio, Decimal('-inf'))
2104 Decimal.as_integer_ratio, Decimal('-nan'))
2106 Decimal.as_integer_ratio, Decimal('snan123'))
2111 d = Decimal('%s%dE%d' % (sign, coeff, exp))
2126 self.assertEqual(Decimal(p) / Decimal(q), d)
2129 # Different behaviours when subclassing Decimal
2130 Decimal = self.decimal.Decimal
2132 class MyDecimal(Decimal):
2138 self.assertIs(type(d), Decimal)
2141 self.assertIs(type(d), Decimal)
2151 # Decimal(Decimal)
2152 d = Decimal('1.0')
2153 x = Decimal(d)
2154 self.assertIs(type(x), Decimal)
2157 # MyDecimal(Decimal)
2163 # Decimal(MyDecimal)
2164 x = Decimal(m)
2165 self.assertIs(type(x), Decimal)
2176 Decimal = self.decimal.Decimal
2177 getcontext = self.decimal.getcontext
2181 self.assertEqual(str(Decimal(0).sqrt()),
2182 str(c.sqrt(Decimal(0))))
2185 Decimal = self.decimal.Decimal
2186 Context = self.decimal.Context
2187 localcontext = self.decimal.localcontext
2188 InvalidOperation = self.decimal.InvalidOperation
2189 DivisionByZero = self.decimal.DivisionByZero
2190 Overflow = self.decimal.Overflow
2191 Underflow = self.decimal.Underflow
2192 Subnormal = self.decimal.Subnormal
2193 Inexact = self.decimal.Inexact
2194 Rounded = self.decimal.Rounded
2195 Clamped = self.decimal.Clamped
2202 x = Decimal("111")
2203 y = Decimal("1e9999")
2204 z = Decimal("1e-9999")
2223 self.assertRaises(InvalidOperation, Decimal(-1).ln, context=None)
2231 self.assertRaises(InvalidOperation, Decimal(-1).log10, context=None)
2236 self.assertRaises(DivisionByZero, Decimal(0).logb, context=None)
2246 self.assertRaises(InvalidOperation, Decimal('sNaN').next_minus, context=None)
2251 self.assertRaises(InvalidOperation, Decimal('sNaN').next_plus, context=None)
2279 ans = str(x.compare(Decimal('Nan891287828'), context=None))
2281 self.assertRaises(InvalidOperation, x.compare, Decimal('sNaN'), context=None)
2287 self.assertRaises(InvalidOperation, x.compare_signal, Decimal('NaN'), context=None)
2311 self.assertRaises(InvalidOperation, x.max, Decimal('sNaN'), context=None)
2317 self.assertRaises(InvalidOperation, x.max_mag, Decimal('sNaN'), context=None)
2323 self.assertRaises(InvalidOperation, x.min, Decimal('sNaN'), context=None)
2329 self.assertRaises(InvalidOperation, x.min_mag, Decimal('sNaN'), context=None)
2361 self.assertRaises(Overflow, x.fma, Decimal('1e9999'), 3, context=None)
2367 ans = str(Decimal('1.5').to_integral(rounding=None, context=None))
2370 ans = str(Decimal('1.5').to_integral(rounding=None, context=None))
2372 ans = str(Decimal('1.5').to_integral(rounding=ROUND_UP, context=None))
2375 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral, context=None)
2379 ans = str(Decimal('1.5').to_integral_value(rounding=None, context=None))
2382 ans = str(Decimal('1.5').to_integral_value(rounding=None, context=None))
2384 ans = str(Decimal('1.5').to_integral_value(rounding=ROUND_UP, context=None))
2387 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral_value, context=None)
2391 ans = str(Decimal('1.5').to_integral_exact(rounding=None, context=None))
2394 ans = str(Decimal('1.5').to_integral_exact(rounding=None, context=None))
2396 ans = str(Decimal('1.5').to_integral_exact(rounding=ROUND_UP, context=None))
2399 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral_exact, context=None)
2403 ans = str(Decimal('1.50001').quantize(exp=Decimal('1e-3'), rounding=None, context=None))
2406 ans = str(Decimal('1.50001').quantize(exp=Decimal('1e-3'), rounding=None, context=None))
2408 … ans = str(Decimal('1.50001').quantize(exp=Decimal('1e-3'), rounding=ROUND_UP, context=None))
2411 … self.assertRaises(InvalidOperation, y.quantize, Decimal('1e-10'), rounding=ROUND_UP, context=None)
2424 # Check that methods taking a second Decimal argument will
2425 # always accept an integer in place of a Decimal.
2426 Decimal = self.decimal.Decimal
2428 self.assertEqual(Decimal(4).compare(3),
2429 Decimal(4).compare(Decimal(3)))
2430 self.assertEqual(Decimal(4).compare_signal(3),
2431 Decimal(4).compare_signal(Decimal(3)))
2432 self.assertEqual(Decimal(4).compare_total(3),
2433 Decimal(4).compare_total(Decimal(3)))
2434 self.assertEqual(Decimal(4).compare_total_mag(3),
2435 Decimal(4).compare_total_mag(Decimal(3)))
2436 self.assertEqual(Decimal(10101).logical_and(1001),
2437 Decimal(10101).logical_and(Decimal(1001)))
2438 self.assertEqual(Decimal(10101).logical_or(1001),
2439 Decimal(10101).logical_or(Decimal(1001)))
2440 self.assertEqual(Decimal(10101).logical_xor(1001),
2441 Decimal(10101).logical_xor(Decimal(1001)))
2442 self.assertEqual(Decimal(567).max(123),
2443 Decimal(567).max(Decimal(123)))
2444 self.assertEqual(Decimal(567).max_mag(123),
2445 Decimal(567).max_mag(Decimal(123)))
2446 self.assertEqual(Decimal(567).min(123),
2447 Decimal(567).min(Decimal(123)))
2448 self.assertEqual(Decimal(567).min_mag(123),
2449 Decimal(567).min_mag(Decimal(123)))
2450 self.assertEqual(Decimal(567).next_toward(123),
2451 Decimal(567).next_toward(Decimal(123)))
2452 self.assertEqual(Decimal(1234).quantize(100),
2453 Decimal(1234).quantize(Decimal(100)))
2454 self.assertEqual(Decimal(768).remainder_near(1234),
2455 Decimal(768).remainder_near(Decimal(1234)))
2456 self.assertEqual(Decimal(123).rotate(1),
2457 Decimal(123).rotate(Decimal(1)))
2458 self.assertEqual(Decimal(1234).same_quantum(1000),
2459 Decimal(1234).same_quantum(Decimal(1000)))
2460 self.assertEqual(Decimal('9.123').scaleb(-100),
2461 Decimal('9.123').scaleb(Decimal(-100)))
2462 self.assertEqual(Decimal(456).shift(-1),
2463 Decimal(456).shift(Decimal(-1)))
2465 self.assertEqual(Decimal(-12).fma(Decimal(45), 67),
2466 Decimal(-12).fma(Decimal(45), Decimal(67)))
2467 self.assertEqual(Decimal(-12).fma(45, 67),
2468 Decimal(-12).fma(Decimal(45), Decimal(67)))
2469 self.assertEqual(Decimal(-12).fma(45, Decimal(67)),
2470 Decimal(-12).fma(Decimal(45), Decimal(67)))
2473 decimal = C variable in CUsabilityTest
2475 decimal = P variable in PyUsabilityTest
2489 Decimal = self.decimal.Decimal
2491 self.assertTrue(issubclass(Decimal, numbers.Number))
2492 self.assertFalse(issubclass(Decimal, numbers.Real))
2493 self.assertIsInstance(Decimal(0), numbers.Number)
2494 self.assertNotIsInstance(Decimal(0), numbers.Real)
2498 Decimal = self.decimal.Decimal
2500 savedecimal = sys.modules['decimal']
2503 sys.modules['decimal'] = self.decimal
2504 d = Decimal('-3.141590000')
2511 x = C.Decimal('-3.123e81723')
2512 y = P.Decimal('-3.123e81723')
2514 sys.modules['decimal'] = C
2516 sys.modules['decimal'] = P
2518 self.assertIsInstance(r, P.Decimal)
2521 sys.modules['decimal'] = P
2523 sys.modules['decimal'] = C
2525 self.assertIsInstance(r, C.Decimal)
2528 x = C.Decimal('-3.123e81723').as_tuple()
2529 y = P.Decimal('-3.123e81723').as_tuple()
2531 sys.modules['decimal'] = C
2533 sys.modules['decimal'] = P
2538 sys.modules['decimal'] = P
2540 sys.modules['decimal'] = C
2545 sys.modules['decimal'] = savedecimal
2548 Decimal = self.decimal.Decimal
2553 self.assertEqual(int(Decimal(s)), int(float(s)))
2555 d = Decimal(s)
2557 self.assertEqual(Decimal(int(d)), r)
2559 self.assertRaises(ValueError, int, Decimal('-nan'))
2560 self.assertRaises(ValueError, int, Decimal('snan'))
2561 self.assertRaises(OverflowError, int, Decimal('inf'))
2562 self.assertRaises(OverflowError, int, Decimal('-inf'))
2565 Decimal = self.decimal.Decimal
2570 self.assertEqual(int(Decimal(s)), int(float(s)))
2572 d = Decimal(s)
2574 self.assertEqual(Decimal(math.trunc(d)), r)
2578 Decimal = self.decimal.Decimal
2580 class MyDecimal(Decimal):
2584 self.assertTrue(issubclass(MyDecimal, Decimal))
2598 str(Decimal('NaN')))
2600 str(Decimal('Infinity')))
2602 str(Decimal('-Infinity')))
2609 Decimal = self.decimal.Decimal
2610 Context = self.decimal.Context
2611 Inexact = self.decimal.Inexact
2616 Decimal('3.1415')
2621 Decimal('3.1416')
2630 "Decimal('-0')")
2632 "Decimal('1')")
2634 "Decimal('10')")
2637 Decimal = self.decimal.Decimal
2638 Context = self.decimal.Context
2639 InvalidOperation = self.decimal.InvalidOperation
2643 Decimal('7.335').quantize(Decimal('.01')),
2644 Decimal('7.34')
2647 Decimal('7.335').quantize(Decimal('.01'), rounding=ROUND_DOWN),
2648 Decimal('7.33')
2652 Decimal("10e99999").quantize, Decimal('1e100000'), context=c
2656 d = Decimal("0.871831e800")
2657 x = d.quantize(context=c, exp=Decimal("1e797"), rounding=ROUND_DOWN)
2658 self.assertEqual(x, Decimal('8.71E+799'))
2661 Decimal = self.decimal.Decimal
2663 x = Decimal("9.8182731e181273")
2668 x = Decimal("1")
2677 D = self.decimal.Decimal
2678 Context = self.decimal.Context
2679 localcontext = self.decimal.localcontext
2680 InvalidOperation = self.decimal.InvalidOperation
2681 Overflow = self.decimal.Overflow
2790 decimal = self.decimal
2791 DecimalException = decimal.DecimalException
2792 InvalidOperation = decimal.InvalidOperation
2793 FloatOperation = decimal.FloatOperation
2794 DivisionByZero = decimal.DivisionByZero
2795 Overflow = decimal.Overflow
2796 Underflow = decimal.Underflow
2797 Subnormal = decimal.Subnormal
2798 Inexact = decimal.Inexact
2799 Rounded = decimal.Rounded
2800 Clamped = decimal.Clamped
2822 self.assertTrue(issubclass(decimal.ConversionSyntax, InvalidOperation))
2823 self.assertTrue(issubclass(decimal.DivisionImpossible, InvalidOperation))
2824 self.assertTrue(issubclass(decimal.DivisionUndefined, InvalidOperation))
2825 self.assertTrue(issubclass(decimal.DivisionUndefined, ZeroDivisionError))
2826 self.assertTrue(issubclass(decimal.InvalidContext, InvalidOperation))
2829 decimal = C variable in CPythonAPItests
2831 decimal = P variable in PyPythonAPItests
2836 Context = self.decimal.Context
2837 InvalidOperation = self.decimal.InvalidOperation
2838 DivisionByZero = self.decimal.DivisionByZero
2839 Overflow = self.decimal.Overflow
2860 c = self.decimal.Context()
2875 Context = self.decimal.Context
2877 savedecimal = sys.modules['decimal']
2880 sys.modules['decimal'] = self.decimal
2907 sys.modules['decimal'] = dumper
2918 sys.modules['decimal'] = loader
2931 sys.modules['decimal'] = savedecimal
2934 Decimal = self.decimal.Decimal
2936 self.assertIn(Decimal(10), ['a', 1.0, Decimal(10), (1,2), {}])
2937 self.assertNotIn(Decimal(10), ['a', 1.0, (1,2), {}])
2941 Decimal = self.decimal.Decimal
2942 Context = self.decimal.Context
2961 Context = self.decimal.Context
2966 Decimal = self.decimal.Decimal
2967 Context = self.decimal.Context
2970 d = c.abs(Decimal(-1))
2975 Decimal = self.decimal.Decimal
2976 Context = self.decimal.Context
2979 d = c.add(Decimal(1), Decimal(1))
2981 self.assertEqual(c.add(Decimal(1), 1), d)
2982 self.assertEqual(c.add(1, Decimal(1)), d)
2987 Decimal = self.decimal.Decimal
2988 Context = self.decimal.Context
2991 d = c.compare(Decimal(1), Decimal(1))
2993 self.assertEqual(c.compare(Decimal(1), 1), d)
2994 self.assertEqual(c.compare(1, Decimal(1)), d)
2999 Decimal = self.decimal.Decimal
3000 Context = self.decimal.Context
3003 d = c.compare_signal(Decimal(1), Decimal(1))
3005 self.assertEqual(c.compare_signal(Decimal(1), 1), d)
3006 self.assertEqual(c.compare_signal(1, Decimal(1)), d)
3011 Decimal = self.decimal.Decimal
3012 Context = self.decimal.Context
3015 d = c.compare_total(Decimal(1), Decimal(1))
3017 self.assertEqual(c.compare_total(Decimal(1), 1), d)
3018 self.assertEqual(c.compare_total(1, Decimal(1)), d)
3023 Decimal = self.decimal.Decimal
3024 Context = self.decimal.Context
3027 d = c.compare_total_mag(Decimal(1), Decimal(1))
3029 self.assertEqual(c.compare_total_mag(Decimal(1), 1), d)
3030 self.assertEqual(c.compare_total_mag(1, Decimal(1)), d)
3035 Decimal = self.decimal.Decimal
3036 Context = self.decimal.Context
3039 d = c.copy_abs(Decimal(-1))
3044 Decimal = self.decimal.Decimal
3045 Context = self.decimal.Context
3048 d = c.copy_decimal(Decimal(-1))
3053 Decimal = self.decimal.Decimal
3054 Context = self.decimal.Context
3057 d = c.copy_negate(Decimal(-1))
3062 Decimal = self.decimal.Decimal
3063 Context = self.decimal.Context
3066 d = c.copy_sign(Decimal(1), Decimal(-2))
3068 self.assertEqual(c.copy_sign(Decimal(1), -2), d)
3069 self.assertEqual(c.copy_sign(1, Decimal(-2)), d)
3074 Decimal = self.decimal.Decimal
3075 Context = self.decimal.Context
3078 d = c.divide(Decimal(1), Decimal(2))
3080 self.assertEqual(c.divide(Decimal(1), 2), d)
3081 self.assertEqual(c.divide(1, Decimal(2)), d)
3086 Decimal = self.decimal.Decimal
3087 Context = self.decimal.Context
3090 d = c.divide_int(Decimal(1), Decimal(2))
3092 self.assertEqual(c.divide_int(Decimal(1), 2), d)
3093 self.assertEqual(c.divide_int(1, Decimal(2)), d)
3098 Decimal = self.decimal.Decimal
3099 Context = self.decimal.Context
3102 d = c.divmod(Decimal(1), Decimal(2))
3104 self.assertEqual(c.divmod(Decimal(1), 2), d)
3105 self.assertEqual(c.divmod(1, Decimal(2)), d)
3110 Decimal = self.decimal.Decimal
3111 Context = self.decimal.Context
3114 d = c.exp(Decimal(10))
3119 Decimal = self.decimal.Decimal
3120 Context = self.decimal.Context
3123 d = c.fma(Decimal(2), Decimal(3), Decimal(4))
3125 self.assertEqual(c.fma(Decimal(2), 3, 4), d)
3126 self.assertEqual(c.fma(2, Decimal(3), 4), d)
3127 self.assertEqual(c.fma(2, 3, Decimal(4)), d)
3128 self.assertEqual(c.fma(Decimal(2), Decimal(3), 4), d)
3135 Decimal('Infinity'), Decimal(0), "not a decimal")
3137 Decimal(1), Decimal('snan'), 1.222)
3138 # ... and for Decimal.fma.
3139 self.assertRaises(TypeError, Decimal('Infinity').fma,
3140 Decimal(0), "not a decimal")
3141 self.assertRaises(TypeError, Decimal(1).fma,
3142 Decimal('snan'), 1.222)
3145 Decimal = self.decimal.Decimal
3146 Context = self.decimal.Context
3149 d = c.is_finite(Decimal(10))
3154 Decimal = self.decimal.Decimal
3155 Context = self.decimal.Context
3158 d = c.is_infinite(Decimal(10))
3163 Decimal = self.decimal.Decimal
3164 Context = self.decimal.Context
3167 d = c.is_nan(Decimal(10))
3172 Decimal = self.decimal.Decimal
3173 Context = self.decimal.Context
3176 d = c.is_normal(Decimal(10))
3181 Decimal = self.decimal.Decimal
3182 Context = self.decimal.Context
3185 d = c.is_qnan(Decimal(10))
3190 Decimal = self.decimal.Decimal
3191 Context = self.decimal.Context
3194 d = c.is_signed(Decimal(10))
3199 Decimal = self.decimal.Decimal
3200 Context = self.decimal.Context
3203 d = c.is_snan(Decimal(10))
3208 Decimal = self.decimal.Decimal
3209 Context = self.decimal.Context
3212 d = c.is_subnormal(Decimal(10))
3217 Decimal = self.decimal.Decimal
3218 Context = self.decimal.Context
3221 d = c.is_zero(Decimal(10))
3226 Decimal = self.decimal.Decimal
3227 Context = self.decimal.Context
3230 d = c.ln(Decimal(10))
3235 Decimal = self.decimal.Decimal
3236 Context = self.decimal.Context
3239 d = c.log10(Decimal(10))
3244 Decimal = self.decimal.Decimal
3245 Context = self.decimal.Context
3248 d = c.logb(Decimal(10))
3253 Decimal = self.decimal.Decimal
3254 Context = self.decimal.Context
3257 d = c.logical_and(Decimal(1), Decimal(1))
3259 self.assertEqual(c.logical_and(Decimal(1), 1), d)
3260 self.assertEqual(c.logical_and(1, Decimal(1)), d)
3265 Decimal = self.decimal.Decimal
3266 Context = self.decimal.Context
3269 d = c.logical_invert(Decimal(1000))
3274 Decimal = self.decimal.Decimal
3275 Context = self.decimal.Context
3278 d = c.logical_or(Decimal(1), Decimal(1))
3280 self.assertEqual(c.logical_or(Decimal(1), 1), d)
3281 self.assertEqual(c.logical_or(1, Decimal(1)), d)
3286 Decimal = self.decimal.Decimal
3287 Context = self.decimal.Context
3290 d = c.logical_xor(Decimal(1), Decimal(1))
3292 self.assertEqual(c.logical_xor(Decimal(1), 1), d)
3293 self.assertEqual(c.logical_xor(1, Decimal(1)), d)
3298 Decimal = self.decimal.Decimal
3299 Context = self.decimal.Context
3302 d = c.max(Decimal(1), Decimal(2))
3304 self.assertEqual(c.max(Decimal(1), 2), d)
3305 self.assertEqual(c.max(1, Decimal(2)), d)
3310 Decimal = self.decimal.Decimal
3311 Context = self.decimal.Context
3314 d = c.max_mag(Decimal(1), Decimal(2))
3316 self.assertEqual(c.max_mag(Decimal(1), 2), d)
3317 self.assertEqual(c.max_mag(1, Decimal(2)), d)
3322 Decimal = self.decimal.Decimal
3323 Context = self.decimal.Context
3326 d = c.min(Decimal(1), Decimal(2))
3328 self.assertEqual(c.min(Decimal(1), 2), d)
3329 self.assertEqual(c.min(1, Decimal(2)), d)
3334 Decimal = self.decimal.Decimal
3335 Context = self.decimal.Context
3338 d = c.min_mag(Decimal(1), Decimal(2))
3340 self.assertEqual(c.min_mag(Decimal(1), 2), d)
3341 self.assertEqual(c.min_mag(1, Decimal(2)), d)
3346 Decimal = self.decimal.Decimal
3347 Context = self.decimal.Context
3350 d = c.minus(Decimal(10))
3355 Decimal = self.decimal.Decimal
3356 Context = self.decimal.Context
3359 d = c.multiply(Decimal(1), Decimal(2))
3361 self.assertEqual(c.multiply(Decimal(1), 2), d)
3362 self.assertEqual(c.multiply(1, Decimal(2)), d)
3367 Decimal = self.decimal.Decimal
3368 Context = self.decimal.Context
3371 d = c.next_minus(Decimal(10))
3376 Decimal = self.decimal.Decimal
3377 Context = self.decimal.Context
3380 d = c.next_plus(Decimal(10))
3385 Decimal = self.decimal.Decimal
3386 Context = self.decimal.Context
3389 d = c.next_toward(Decimal(1), Decimal(2))
3391 self.assertEqual(c.next_toward(Decimal(1), 2), d)
3392 self.assertEqual(c.next_toward(1, Decimal(2)), d)
3397 Decimal = self.decimal.Decimal
3398 Context = self.decimal.Context
3401 d = c.normalize(Decimal(10))
3406 Decimal = self.decimal.Decimal
3407 Context = self.decimal.Context
3410 self.assertEqual(c.number_class(123), c.number_class(Decimal(123)))
3411 self.assertEqual(c.number_class(0), c.number_class(Decimal(0)))
3412 self.assertEqual(c.number_class(-45), c.number_class(Decimal(-45)))
3415 Decimal = self.decimal.Decimal
3416 Context = self.decimal.Context
3419 d = c.plus(Decimal(10))
3424 Decimal = self.decimal.Decimal
3425 Context = self.decimal.Context
3428 d = c.power(Decimal(1), Decimal(4))
3430 self.assertEqual(c.power(Decimal(1), 4), d)
3431 self.assertEqual(c.power(1, Decimal(4)), d)
3432 self.assertEqual(c.power(Decimal(1), Decimal(4)), d)
3438 Decimal = self.decimal.Decimal
3439 Context = self.decimal.Context
3442 d = c.quantize(Decimal(1), Decimal(2))
3444 self.assertEqual(c.quantize(Decimal(1), 2), d)
3445 self.assertEqual(c.quantize(1, Decimal(2)), d)
3450 Decimal = self.decimal.Decimal
3451 Context = self.decimal.Context
3454 d = c.remainder(Decimal(1), Decimal(2))
3456 self.assertEqual(c.remainder(Decimal(1), 2), d)
3457 self.assertEqual(c.remainder(1, Decimal(2)), d)
3462 Decimal = self.decimal.Decimal
3463 Context = self.decimal.Context
3466 d = c.remainder_near(Decimal(1), Decimal(2))
3468 self.assertEqual(c.remainder_near(Decimal(1), 2), d)
3469 self.assertEqual(c.remainder_near(1, Decimal(2)), d)
3474 Decimal = self.decimal.Decimal
3475 Context = self.decimal.Context
3478 d = c.rotate(Decimal(1), Decimal(2))
3480 self.assertEqual(c.rotate(Decimal(1), 2), d)
3481 self.assertEqual(c.rotate(1, Decimal(2)), d)
3486 Decimal = self.decimal.Decimal
3487 Context = self.decimal.Context
3490 d = c.sqrt(Decimal(10))
3495 Decimal = self.decimal.Decimal
3496 Context = self.decimal.Context
3499 d = c.same_quantum(Decimal(1), Decimal(2))
3501 self.assertEqual(c.same_quantum(Decimal(1), 2), d)
3502 self.assertEqual(c.same_quantum(1, Decimal(2)), d)
3507 Decimal = self.decimal.Decimal
3508 Context = self.decimal.Context
3511 d = c.scaleb(Decimal(1), Decimal(2))
3513 self.assertEqual(c.scaleb(Decimal(1), 2), d)
3514 self.assertEqual(c.scaleb(1, Decimal(2)), d)
3519 Decimal = self.decimal.Decimal
3520 Context = self.decimal.Context
3523 d = c.shift(Decimal(1), Decimal(2))
3525 self.assertEqual(c.shift(Decimal(1), 2), d)
3526 self.assertEqual(c.shift(1, Decimal(2)), d)
3531 Decimal = self.decimal.Decimal
3532 Context = self.decimal.Context
3535 d = c.subtract(Decimal(1), Decimal(2))
3537 self.assertEqual(c.subtract(Decimal(1), 2), d)
3538 self.assertEqual(c.subtract(1, Decimal(2)), d)
3543 Decimal = self.decimal.Decimal
3544 Context = self.decimal.Context
3547 d = c.to_eng_string(Decimal(10))
3552 Decimal = self.decimal.Decimal
3553 Context = self.decimal.Context
3556 d = c.to_sci_string(Decimal(10))
3561 Decimal = self.decimal.Decimal
3562 Context = self.decimal.Context
3565 d = c.to_integral_exact(Decimal(10))
3570 Decimal = self.decimal.Decimal
3571 Context = self.decimal.Context
3574 d = c.to_integral_value(Decimal(10))
3580 decimal = C variable in CContextAPItests
3582 decimal = P variable in PyContextAPItests
3590 getcontext = self.decimal.getcontext
3591 localcontext = self.decimal.localcontext
3603 Context = self.decimal.Context
3604 getcontext = self.decimal.getcontext
3605 localcontext = self.decimal.localcontext
3607 localcontext = self.decimal.localcontext
3620 Decimal = self.decimal.Decimal
3621 Context = self.decimal.Context
3622 getcontext = self.decimal.getcontext
3623 localcontext = self.decimal.localcontext
3624 Clamped = self.decimal.Clamped
3625 Overflow = self.decimal.Overflow
3641 self.assertRaises(Overflow, c2.power, Decimal('3.4e200'), 2)
3654 localcontext = self.decimal.localcontext
3666 localcontext = self.decimal.localcontext
3678 Context = self.decimal.Context
3679 localcontext = self.decimal.localcontext
3680 getcontext = self.decimal.getcontext
3681 setcontext = self.decimal.setcontext
3711 decimal = C variable in CContextWithStatement
3713 decimal = P variable in PyContextWithStatement
3720 Decimal = self.decimal.Decimal
3721 Context = self.decimal.Context
3722 Inexact = self.decimal.Inexact
3723 Rounded = self.decimal.Rounded
3724 Underflow = self.decimal.Underflow
3725 Clamped = self.decimal.Clamped
3726 Subnormal = self.decimal.Subnormal
3729 if self.decimal == C:
3741 (context._apply, [Decimal("100E-425000010")]),
3742 (context.sqrt, [Decimal(2)]),
3743 (context.add, [Decimal("1.23456789"), Decimal("9.87654321")]),
3744 (context.multiply, [Decimal("1.23456789"), Decimal("9.87654321")]),
3745 (context.subtract, [Decimal("1.23456789"), Decimal("9.87654321")]),
3784 Context = self.decimal.Context
3785 Inexact = self.decimal.Inexact
3786 Rounded = self.decimal.Rounded
3823 Decimal = self.decimal.Decimal
3824 FloatOperation = self.decimal.FloatOperation
3825 localcontext = self.decimal.localcontext
3833 self.assertEqual(Decimal(7.5), 7.5)
3842 x = Decimal.from_float(7.5)
3859 self.assertRaises(FloatOperation, Decimal, 7.5)
3868 x = Decimal.from_float(7.5)
3876 Decimal = self.decimal.Decimal
3877 Context = self.decimal.Context
3878 FloatOperation = self.decimal.FloatOperation
3879 localcontext = self.decimal.localcontext
3890 small_d = Decimal('0.25')
3891 big_d = Decimal('3.0')
3895 zero_d = Decimal('0.0')
3896 neg_zero_d = Decimal('-0.0')
3900 inf_d = Decimal('Infinity')
3901 neg_inf_d = Decimal('-Infinity')
3928 assert_attr(Decimal('0.1'), 0.1, '__ne__', c, None)
3933 assert_attr(Decimal('NaN'), float('nan'), '__ne__', c, None)
3937 s = set([100.0, Decimal('100.0')])
3943 self.assertRaises(signal, sorted, [1.0, Decimal('10.0')])
3945 s = sorted([10.0, Decimal('10.0')])
3949 b = 10.0 in [Decimal('10.0'), 1.0]
3953 b = 10.0 in {Decimal('10.0'):'a', 1.0:'b'}
3967 Decimal = self.decimal.Decimal
3968 Context = self.decimal.Context
3969 Inexact = self.decimal.Inexact
3970 FloatOperation= self.decimal.FloatOperation
3983 decimal = C variable in CContextFlags
3985 decimal = P variable in PyContextFlags
3991 BasicContext = self.decimal.BasicContext
3992 ExtendedContext = self.decimal.ExtendedContext
3993 getcontext = self.decimal.getcontext
3994 setcontext = self.decimal.setcontext
3995 InvalidOperation = self.decimal.InvalidOperation
3996 DivisionByZero = self.decimal.DivisionByZero
3997 Overflow = self.decimal.Overflow
3998 Underflow = self.decimal.Underflow
3999 Clamped = self.decimal.Clamped
4027 DefaultContext = self.decimal.DefaultContext
4028 BasicContext = self.decimal.BasicContext
4029 ExtendedContext = self.decimal.ExtendedContext
4030 getcontext = self.decimal.getcontext
4031 setcontext = self.decimal.setcontext
4032 InvalidOperation = self.decimal.InvalidOperation
4033 DivisionByZero = self.decimal.DivisionByZero
4034 Overflow = self.decimal.Overflow
4068 decimal = C variable in CSpecialContexts
4070 decimal = P variable in PySpecialContexts
4075 Context = self.decimal.Context
4076 DefaultContext = self.decimal.DefaultContext
4135 decimal = C variable in CContextInputValidation
4137 decimal = P variable in PyContextInputValidation
4142 decimal = self.decimal
4143 Decimal = decimal.Decimal
4144 Context = decimal.Context
4145 Clamped = decimal.Clamped
4146 DivisionByZero = decimal.DivisionByZero
4147 Inexact = decimal.Inexact
4148 Overflow = decimal.Overflow
4149 Rounded = decimal.Rounded
4150 Subnormal = decimal.Subnormal
4151 Underflow = decimal.Underflow
4152 InvalidOperation = decimal.InvalidOperation
4173 flags = {v:(v in flags) for v in OrderedSignals[decimal] + flags}
4177 traps = {v:(v in traps) for v in OrderedSignals[decimal] + traps}
4190 self.assertRaises(InvalidOperation, c.quantize, Decimal('9e2'), 0)
4196 self.assertEqual(c.plus(Decimal('9.9')), 9)
4202 x = c.add(Decimal('1e-99'), Decimal('2.234e-2000'))
4203 self.assertEqual(x, Decimal('0.0'))
4211 self.assertRaises(Overflow, c.add, Decimal('1e99'), Decimal('2.234e2000'))
4212 if self.decimal == C:
4227 x = c.plus(Decimal('1e99'))
4236 for signal in OrderedSignals[decimal]:
4245 for signal in OrderedSignals[decimal]:
4249 decimal = C variable in CContextSubclassing
4251 decimal = P variable in PyContextSubclassing
4279 x = [s for s in dir(C.Decimal(9)) if '__' in s or not s.startswith('_')]
4280 y = [s for s in dir(C.Decimal(9)) if '__' in s or not s.startswith('_')]
4286 Decimal = self.decimal.Decimal
4288 self.assertEqual(Decimal('1234e9999').adjusted(), 10002)
4290 self.assertEqual(Decimal('nan').adjusted(), 0)
4291 self.assertEqual(Decimal('inf').adjusted(), 0)
4294 Decimal = self.decimal.Decimal
4295 getcontext = self.decimal.getcontext
4297 x = Decimal(9).canonical()
4301 x = c.canonical(Decimal(9))
4305 c = self.decimal.DefaultContext.copy()
4313 for sig in OrderedSignals[self.decimal]:
4324 Decimal = self.decimal.Decimal
4325 localcontext = self.decimal.localcontext
4333 self.assertEqual(abs(Decimal("-10")), 10)
4335 self.assertEqual(Decimal("7") + 1, 8)
4337 self.assertEqual(Decimal("10") / 5, 2)
4339 self.assertEqual(Decimal("10") // 7, 1)
4341 self.assertEqual(Decimal("1.2").fma(Decimal("0.01"), 1), 1)
4342 self.assertIs(Decimal("NaN").fma(7, 1).is_nan(), True)
4344 self.assertEqual(pow(Decimal(10), 2, 7), 2)
4346 self.assertEqual(Decimal("1.01").exp(), 3)
4348 self.assertIs(Decimal("0.01").is_normal(), False)
4350 self.assertIs(Decimal("0.01").is_subnormal(), True)
4352 self.assertEqual(Decimal("20").ln(), 3)
4354 self.assertEqual(Decimal("20").log10(), 1)
4356 self.assertEqual(Decimal("580").logb(), 2)
4358 self.assertEqual(Decimal("10").logical_invert(), 1)
4360 self.assertEqual(-Decimal("-10"), 10)
4362 self.assertEqual(Decimal("2") * 4, 8)
4364 self.assertEqual(Decimal("10").next_minus(), 9)
4366 self.assertEqual(Decimal("10").next_plus(), Decimal('2E+1'))
4368 self.assertEqual(Decimal("-10").normalize(), Decimal('-1E+1'))
4370 self.assertEqual(Decimal("10").number_class(), '+Normal')
4372 self.assertEqual(+Decimal("-1"), -1)
4374 self.assertEqual(Decimal("10") % 7, 3)
4376 self.assertEqual(Decimal("10") - 7, 3)
4378 self.assertEqual(Decimal("1.12345").to_integral_exact(), 1)
4381 self.assertTrue(Decimal("1").is_canonical())
4382 self.assertTrue(Decimal("1").is_finite())
4383 self.assertTrue(Decimal("1").is_finite())
4384 self.assertTrue(Decimal("snan").is_snan())
4385 self.assertTrue(Decimal("-1").is_signed())
4386 self.assertTrue(Decimal("0").is_zero())
4387 self.assertTrue(Decimal("0").is_zero())
4393 y = -Decimal(x)
4401 z = y.copy_sign(Decimal(1))
4405 Decimal = self.decimal.Decimal
4406 localcontext = self.decimal.localcontext
4407 InvalidOperation = self.decimal.InvalidOperation
4408 DivisionByZero = self.decimal.DivisionByZero
4411 q, r = divmod(Decimal("10912837129"), 1001)
4412 self.assertEqual(q, Decimal('10901935'))
4413 self.assertEqual(r, Decimal('194'))
4415 q, r = divmod(Decimal("NaN"), 7)
4419 q, r = divmod(Decimal("NaN"), 7)
4424 q, r = divmod(Decimal("inf"), Decimal("inf"))
4429 q, r = divmod(Decimal("inf"), 101)
4434 q, r = divmod(Decimal(0), 0)
4440 q, r = divmod(Decimal(11), 0)
4446 Decimal = self.decimal.Decimal
4447 localcontext = self.decimal.localcontext
4448 Overflow = self.decimal.Overflow
4449 Rounded = self.decimal.Rounded
4454 self.assertEqual(Decimal("1.0") ** 100, Decimal('1.00'))
4462 self.assertEqual(Decimal(10000) ** Decimal("0.5"), Decimal('inf'))
4466 Decimal = self.decimal.Decimal
4467 localcontext = self.decimal.localcontext
4468 InvalidOperation = self.decimal.InvalidOperation
4475 x = Decimal(99).quantize(Decimal("1e1"))
4479 Decimal = self.decimal.Decimal
4480 getcontext = self.decimal.getcontext
4483 self.assertEqual(Decimal("1").radix(), 10)
4487 Decimal = self.decimal.Decimal
4491 self.assertIs(getattr(Decimal("1"), attr)("xyz"), NotImplemented)
4494 # Python3 behavior: round() returns Decimal
4495 Decimal = self.decimal.Decimal
4496 localcontext = self.decimal.localcontext
4501 self.assertEqual(str(Decimal("9.99").__round__()), "10")
4502 self.assertEqual(str(Decimal("9.99e-5").__round__()), "0")
4503 self.assertEqual(str(Decimal("1.23456789").__round__(5)), "1.23457")
4504 self.assertEqual(str(Decimal("1.2345").__round__(10)), "1.2345000000")
4505 self.assertEqual(str(Decimal("1.2345").__round__(-10)), "0E+10")
4507 self.assertRaises(TypeError, Decimal("1.23").__round__, "5")
4508 self.assertRaises(TypeError, Decimal("1.23").__round__, 5, 8)
4511 c = self.decimal.Context()
4515 Decimal = self.decimal.Decimal
4516 localcontext = self.decimal.localcontext
4520 x = Decimal(1221**1271) / 10**3923
4525 Context = self.decimal.Context
4541 decimal = C variable in CCoverage
4543 decimal = P variable in PyCoverage
4555 """Extra functionality in decimal.py"""
4558 # triples giving a format, a Decimal, and the expected result
4559 Decimal = P.Decimal
4576 self.assertEqual(format(Decimal(d), fmt), result)
4579 """White box testing for decimal.py"""
4583 Decimal = P.Decimal
4588 x = Decimal(2**16) ** Decimal("-0.5")
4589 self.assertEqual(x, Decimal('0.00390625'))
4591 x = Decimal(2**16) ** Decimal("-0.6")
4592 self.assertEqual(x, Decimal('0.0012885819'))
4594 x = Decimal("256e7") ** Decimal("-0.5")
4596 x = Decimal(152587890625) ** Decimal('-0.0625')
4597 self.assertEqual(x, Decimal("0.2"))
4599 x = Decimal("152587890625e7") ** Decimal('-0.0625')
4601 x = Decimal(5**2659) ** Decimal('-0.0625')
4604 x = Decimal("152587890625") ** Decimal('-0.5')
4606 x = Decimal(2**578) ** Decimal("-0.5")
4610 Decimal = P.Decimal
4618 d1 = Decimal('-25e55')
4619 b1 = Decimal('-25e55')
4620 d2 = Decimal('33e+33')
4621 b2 = Decimal('33e+33')
4638 Decimal(d1)
4688 Decimal = P.Decimal
4690 d = Decimal(45)
4691 e = Decimal(d)
4697 Decimal = P.Decimal
4701 x = Decimal("NaN")._rescale(3, ROUND_UP)
4706 Decimal = P.Decimal
4708 self.assertRaises(ValueError, Decimal("3.1234")._round, 0, ROUND_UP)
4715 # issue 8786: Add support for IEEE 754 contexts to decimal module.
4801 Decimal = C.Decimal
4812 y = Decimal(a) ** Decimal(b)
4816 self.assertRaises(TypeError, C.Decimal, 9, "xyz")
4820 Decimal = C.Decimal
4826 self.assertRaises(InvalidOperation, Decimal,
5062 Decimal = C.Decimal
5071 self.assertRaises(InvalidOperation, Decimal("1.23").__round__,
5073 self.assertRaises(InvalidOperation, Decimal("1.23").__round__,
5075 self.assertRaises(InvalidOperation, Decimal("1").__round__,
5077 self.assertRaises(C.InvalidOperation, Decimal("1").__round__,
5079 self.assertRaises(OverflowError, Decimal("1.23").__round__,
5081 self.assertRaises(OverflowError, Decimal("1.23").__round__,
5086 Decimal = C.Decimal
5089 self.assertRaises(TypeError, Decimal(1).__format__, "=10.10", [], 9)
5090 self.assertRaises(TypeError, Decimal(1).__format__, "=10.10", 9)
5091 self.assertRaises(TypeError, Decimal(1).__format__, [])
5093 self.assertRaises(ValueError, Decimal(1).__format__, "<>=10.10")
5095 self.assertRaises(ValueError, Decimal("1.23456789").__format__,
5099 Decimal = C.Decimal
5103 x = Decimal(10)
5120 x = Decimal("99999999999999999999999999.9").to_integral_value(ROUND_UP)
5121 self.assertEqual(x, Decimal('100000000000000000000000000'))
5123 x = Decimal("99999999999999999999999999.9").to_integral_exact(ROUND_UP)
5124 self.assertEqual(x, Decimal('100000000000000000000000000'))
5127 self.assertRaises(Inexact, Decimal("999.9").to_integral_exact, ROUND_UP)
5131 Decimal = C.Decimal
5137 self.assertEqual(Decimal('9.99e10').to_eng_string(), '99.9E+9')
5139 self.assertRaises(TypeError, pow, Decimal(1), 2, "3")
5140 self.assertRaises(TypeError, Decimal(9).number_class, "x", "y")
5141 self.assertRaises(TypeError, Decimal(9).same_quantum, 3, "x", "y")
5145 Decimal("1.23456789").quantize, Decimal('1e-100000'), []
5149 Decimal("1.23456789").quantize, Decimal('1e-100000'), getcontext()
5153 Decimal("1.23456789").quantize, Decimal('1e-100000'), 10
5157 Decimal("1.23456789").quantize, Decimal('1e-100000'), ROUND_UP, 1000
5164 self.assertRaises(TypeError, c.copy_sign, Decimal(1), "x", "y")
5170 self.assertEqual(str(c.canonical(Decimal(200))), '200')
5174 self.assertRaises(DivisionByZero, Decimal(9).__divmod__, 0)
5180 self.assertRaises(InvalidOperation, Decimal(9).__divmod__, 0)
5186 self.assertRaises(InvalidOperation, pow, Decimal(1000), 1, 501)
5189 Decimal = C.Decimal
5192 x = Decimal("10001111111")
5379 Decimal = C.Decimal
5390 return Decimal(x).__format__(fmt, override)
5416 Decimal = C.Decimal
5426 self.assertRaises(InvalidOperation, Decimal, x)
5429 self.assertRaises(InvalidOperation, Decimal, x)
5433 self.assertRaises(InvalidOperation, Decimal, x)
5437 self.assertRaises(InvalidOperation, Decimal, x)
5440 Decimal = C.Decimal
5455 self.assertRaises(InvalidOperation, Decimal, x)
5459 self.assertRaises(InvalidOperation, Decimal, x)
5464 self.assertRaises(InvalidOperation, Decimal, x)
5468 self.assertRaises(InvalidOperation, Decimal, x)
5473 self.assertRaises(OverflowError, Decimal, x)
5477 self.assertRaises(OverflowError, Decimal, x)
5481 self.assertEqual(str(Decimal(x)), '-sNaN')
5483 self.assertEqual(str(Decimal(x)), '-sNaN')
5485 self.assertEqual(str(Decimal(x)), '-sNaN1')
5488 Decimal = C.Decimal
5491 self.assertGreater(Decimal(0).__sizeof__(), 0)
5493 x = Decimal(10**(19*24)).__sizeof__()
5494 y = Decimal(10**(19*25)).__sizeof__()
5497 x = Decimal(10**(9*24)).__sizeof__()
5498 y = Decimal(10**(9*25)).__sizeof__()
5502 Decimal = C.Decimal
5526 self.assertEqual(Decimal.from_float(cls(101.1)),
5527 Decimal.from_float(101.1))
5547 Decimal = C.Decimal
5555 self.assertEqual(Decimal(0).exp(), 1)
5556 self.assertEqual(Decimal(1).ln(), 0)
5557 self.assertEqual(Decimal(1).log10(), 0)
5558 self.assertEqual(Decimal(10**2).log10(), 2)
5559 self.assertEqual(Decimal(10**223).log10(), 223)
5560 self.assertEqual(Decimal(10**19).logb(), 19)
5561 self.assertEqual(Decimal(4).sqrt(), 2)
5562 self.assertEqual(Decimal("40E9").sqrt(), Decimal('2.0E+5'))
5563 self.assertEqual(divmod(Decimal(10), 3), (3, 1))
5564 self.assertEqual(Decimal(10) // 3, 3)
5565 self.assertEqual(Decimal(4) / 2, 2)
5566 self.assertEqual(Decimal(400) ** -1, Decimal('0.0025'))
5580 if (attr == 'Decimal' or attr == 'Context' or
5608 pdict = {C: {'other': C.Decimal(1),
5609 'third': C.Decimal(1),
5610 'x': C.Decimal(1),
5611 'y': C.Decimal(1),
5612 'z': C.Decimal(1),
5613 'a': C.Decimal(1),
5614 'b': C.Decimal(1),
5615 'c': C.Decimal(1),
5616 'exp': C.Decimal(1),
5617 'modulo': C.Decimal(1),
5622 P: {'other': P.Decimal(1),
5623 'third': P.Decimal(1),
5624 'a': P.Decimal(1),
5625 'b': P.Decimal(1),
5626 'c': P.Decimal(1),
5627 'exp': P.Decimal(1),
5628 'modulo': P.Decimal(1),
5682 if ty == 'Decimal':
5702 doit('Decimal')
5737 Runs all arithmetic tests if arith is True or if the "decimal" resource
5744 TEST_ALL = arith if arith is not None else is_resource_enabled('decimal')
5771 savedecimal = sys.modules['decimal']
5773 sys.modules['decimal'] = C
5775 sys.modules['decimal'] = P
5777 sys.modules['decimal'] = savedecimal
5784 if not orig_sys_decimal is sys.modules['decimal']:
5786 "sys.modules['decimal'].")