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
2480 Decimal = self.decimal.Decimal
2482 self.assertTrue(issubclass(Decimal, numbers.Number))
2483 self.assertFalse(issubclass(Decimal, numbers.Real))
2484 self.assertIsInstance(Decimal(0), numbers.Number)
2485 self.assertNotIsInstance(Decimal(0), numbers.Real)
2489 Decimal = self.decimal.Decimal
2491 savedecimal = sys.modules['decimal']
2494 sys.modules['decimal'] = self.decimal
2495 d = Decimal('-3.141590000')
2502 x = C.Decimal('-3.123e81723')
2503 y = P.Decimal('-3.123e81723')
2505 sys.modules['decimal'] = C
2507 sys.modules['decimal'] = P
2509 self.assertIsInstance(r, P.Decimal)
2512 sys.modules['decimal'] = P
2514 sys.modules['decimal'] = C
2516 self.assertIsInstance(r, C.Decimal)
2519 x = C.Decimal('-3.123e81723').as_tuple()
2520 y = P.Decimal('-3.123e81723').as_tuple()
2522 sys.modules['decimal'] = C
2524 sys.modules['decimal'] = P
2529 sys.modules['decimal'] = P
2531 sys.modules['decimal'] = C
2536 sys.modules['decimal'] = savedecimal
2539 Decimal = self.decimal.Decimal
2544 self.assertEqual(int(Decimal(s)), int(float(s)))
2546 d = Decimal(s)
2548 self.assertEqual(Decimal(int(d)), r)
2550 self.assertRaises(ValueError, int, Decimal('-nan'))
2551 self.assertRaises(ValueError, int, Decimal('snan'))
2552 self.assertRaises(OverflowError, int, Decimal('inf'))
2553 self.assertRaises(OverflowError, int, Decimal('-inf'))
2556 Decimal = self.decimal.Decimal
2561 self.assertEqual(int(Decimal(s)), int(float(s)))
2563 d = Decimal(s)
2565 self.assertEqual(Decimal(math.trunc(d)), r)
2569 Decimal = self.decimal.Decimal
2571 class MyDecimal(Decimal):
2575 self.assertTrue(issubclass(MyDecimal, Decimal))
2589 str(Decimal('NaN')))
2591 str(Decimal('Infinity')))
2593 str(Decimal('-Infinity')))
2600 Decimal = self.decimal.Decimal
2601 Context = self.decimal.Context
2602 Inexact = self.decimal.Inexact
2607 Decimal('3.1415')
2612 Decimal('3.1416')
2621 "Decimal('-0')")
2623 "Decimal('1')")
2625 "Decimal('10')")
2628 Decimal = self.decimal.Decimal
2629 Context = self.decimal.Context
2630 InvalidOperation = self.decimal.InvalidOperation
2634 Decimal('7.335').quantize(Decimal('.01')),
2635 Decimal('7.34')
2638 Decimal('7.335').quantize(Decimal('.01'), rounding=ROUND_DOWN),
2639 Decimal('7.33')
2643 Decimal("10e99999").quantize, Decimal('1e100000'), context=c
2647 d = Decimal("0.871831e800")
2648 x = d.quantize(context=c, exp=Decimal("1e797"), rounding=ROUND_DOWN)
2649 self.assertEqual(x, Decimal('8.71E+799'))
2652 Decimal = self.decimal.Decimal
2654 x = Decimal("9.8182731e181273")
2659 x = Decimal("1")
2668 D = self.decimal.Decimal
2669 Context = self.decimal.Context
2670 localcontext = self.decimal.localcontext
2671 InvalidOperation = self.decimal.InvalidOperation
2672 Overflow = self.decimal.Overflow
2781 decimal = self.decimal
2782 DecimalException = decimal.DecimalException
2783 InvalidOperation = decimal.InvalidOperation
2784 FloatOperation = decimal.FloatOperation
2785 DivisionByZero = decimal.DivisionByZero
2786 Overflow = decimal.Overflow
2787 Underflow = decimal.Underflow
2788 Subnormal = decimal.Subnormal
2789 Inexact = decimal.Inexact
2790 Rounded = decimal.Rounded
2791 Clamped = decimal.Clamped
2813 self.assertTrue(issubclass(decimal.ConversionSyntax, InvalidOperation))
2814 self.assertTrue(issubclass(decimal.DivisionImpossible, InvalidOperation))
2815 self.assertTrue(issubclass(decimal.DivisionUndefined, InvalidOperation))
2816 self.assertTrue(issubclass(decimal.DivisionUndefined, ZeroDivisionError))
2817 self.assertTrue(issubclass(decimal.InvalidContext, InvalidOperation))
2820 decimal = C variable in CPythonAPItests
2822 decimal = P variable in PyPythonAPItests
2827 Context = self.decimal.Context
2828 InvalidOperation = self.decimal.InvalidOperation
2829 DivisionByZero = self.decimal.DivisionByZero
2830 Overflow = self.decimal.Overflow
2851 c = self.decimal.Context()
2866 Context = self.decimal.Context
2868 savedecimal = sys.modules['decimal']
2871 sys.modules['decimal'] = self.decimal
2898 sys.modules['decimal'] = dumper
2909 sys.modules['decimal'] = loader
2922 sys.modules['decimal'] = savedecimal
2925 Decimal = self.decimal.Decimal
2927 self.assertIn(Decimal(10), ['a', 1.0, Decimal(10), (1,2), {}])
2928 self.assertNotIn(Decimal(10), ['a', 1.0, (1,2), {}])
2932 Decimal = self.decimal.Decimal
2933 Context = self.decimal.Context
2952 Context = self.decimal.Context
2957 Decimal = self.decimal.Decimal
2958 Context = self.decimal.Context
2961 d = c.abs(Decimal(-1))
2966 Decimal = self.decimal.Decimal
2967 Context = self.decimal.Context
2970 d = c.add(Decimal(1), Decimal(1))
2972 self.assertEqual(c.add(Decimal(1), 1), d)
2973 self.assertEqual(c.add(1, Decimal(1)), d)
2978 Decimal = self.decimal.Decimal
2979 Context = self.decimal.Context
2982 d = c.compare(Decimal(1), Decimal(1))
2984 self.assertEqual(c.compare(Decimal(1), 1), d)
2985 self.assertEqual(c.compare(1, Decimal(1)), d)
2990 Decimal = self.decimal.Decimal
2991 Context = self.decimal.Context
2994 d = c.compare_signal(Decimal(1), Decimal(1))
2996 self.assertEqual(c.compare_signal(Decimal(1), 1), d)
2997 self.assertEqual(c.compare_signal(1, Decimal(1)), d)
3002 Decimal = self.decimal.Decimal
3003 Context = self.decimal.Context
3006 d = c.compare_total(Decimal(1), Decimal(1))
3008 self.assertEqual(c.compare_total(Decimal(1), 1), d)
3009 self.assertEqual(c.compare_total(1, Decimal(1)), d)
3014 Decimal = self.decimal.Decimal
3015 Context = self.decimal.Context
3018 d = c.compare_total_mag(Decimal(1), Decimal(1))
3020 self.assertEqual(c.compare_total_mag(Decimal(1), 1), d)
3021 self.assertEqual(c.compare_total_mag(1, Decimal(1)), d)
3026 Decimal = self.decimal.Decimal
3027 Context = self.decimal.Context
3030 d = c.copy_abs(Decimal(-1))
3035 Decimal = self.decimal.Decimal
3036 Context = self.decimal.Context
3039 d = c.copy_decimal(Decimal(-1))
3044 Decimal = self.decimal.Decimal
3045 Context = self.decimal.Context
3048 d = c.copy_negate(Decimal(-1))
3053 Decimal = self.decimal.Decimal
3054 Context = self.decimal.Context
3057 d = c.copy_sign(Decimal(1), Decimal(-2))
3059 self.assertEqual(c.copy_sign(Decimal(1), -2), d)
3060 self.assertEqual(c.copy_sign(1, Decimal(-2)), d)
3065 Decimal = self.decimal.Decimal
3066 Context = self.decimal.Context
3069 d = c.divide(Decimal(1), Decimal(2))
3071 self.assertEqual(c.divide(Decimal(1), 2), d)
3072 self.assertEqual(c.divide(1, Decimal(2)), d)
3077 Decimal = self.decimal.Decimal
3078 Context = self.decimal.Context
3081 d = c.divide_int(Decimal(1), Decimal(2))
3083 self.assertEqual(c.divide_int(Decimal(1), 2), d)
3084 self.assertEqual(c.divide_int(1, Decimal(2)), d)
3089 Decimal = self.decimal.Decimal
3090 Context = self.decimal.Context
3093 d = c.divmod(Decimal(1), Decimal(2))
3095 self.assertEqual(c.divmod(Decimal(1), 2), d)
3096 self.assertEqual(c.divmod(1, Decimal(2)), d)
3101 Decimal = self.decimal.Decimal
3102 Context = self.decimal.Context
3105 d = c.exp(Decimal(10))
3110 Decimal = self.decimal.Decimal
3111 Context = self.decimal.Context
3114 d = c.fma(Decimal(2), Decimal(3), Decimal(4))
3116 self.assertEqual(c.fma(Decimal(2), 3, 4), d)
3117 self.assertEqual(c.fma(2, Decimal(3), 4), d)
3118 self.assertEqual(c.fma(2, 3, Decimal(4)), d)
3119 self.assertEqual(c.fma(Decimal(2), Decimal(3), 4), d)
3126 Decimal('Infinity'), Decimal(0), "not a decimal")
3128 Decimal(1), Decimal('snan'), 1.222)
3129 # ... and for Decimal.fma.
3130 self.assertRaises(TypeError, Decimal('Infinity').fma,
3131 Decimal(0), "not a decimal")
3132 self.assertRaises(TypeError, Decimal(1).fma,
3133 Decimal('snan'), 1.222)
3136 Decimal = self.decimal.Decimal
3137 Context = self.decimal.Context
3140 d = c.is_finite(Decimal(10))
3145 Decimal = self.decimal.Decimal
3146 Context = self.decimal.Context
3149 d = c.is_infinite(Decimal(10))
3154 Decimal = self.decimal.Decimal
3155 Context = self.decimal.Context
3158 d = c.is_nan(Decimal(10))
3163 Decimal = self.decimal.Decimal
3164 Context = self.decimal.Context
3167 d = c.is_normal(Decimal(10))
3172 Decimal = self.decimal.Decimal
3173 Context = self.decimal.Context
3176 d = c.is_qnan(Decimal(10))
3181 Decimal = self.decimal.Decimal
3182 Context = self.decimal.Context
3185 d = c.is_signed(Decimal(10))
3190 Decimal = self.decimal.Decimal
3191 Context = self.decimal.Context
3194 d = c.is_snan(Decimal(10))
3199 Decimal = self.decimal.Decimal
3200 Context = self.decimal.Context
3203 d = c.is_subnormal(Decimal(10))
3208 Decimal = self.decimal.Decimal
3209 Context = self.decimal.Context
3212 d = c.is_zero(Decimal(10))
3217 Decimal = self.decimal.Decimal
3218 Context = self.decimal.Context
3221 d = c.ln(Decimal(10))
3226 Decimal = self.decimal.Decimal
3227 Context = self.decimal.Context
3230 d = c.log10(Decimal(10))
3235 Decimal = self.decimal.Decimal
3236 Context = self.decimal.Context
3239 d = c.logb(Decimal(10))
3244 Decimal = self.decimal.Decimal
3245 Context = self.decimal.Context
3248 d = c.logical_and(Decimal(1), Decimal(1))
3250 self.assertEqual(c.logical_and(Decimal(1), 1), d)
3251 self.assertEqual(c.logical_and(1, Decimal(1)), d)
3256 Decimal = self.decimal.Decimal
3257 Context = self.decimal.Context
3260 d = c.logical_invert(Decimal(1000))
3265 Decimal = self.decimal.Decimal
3266 Context = self.decimal.Context
3269 d = c.logical_or(Decimal(1), Decimal(1))
3271 self.assertEqual(c.logical_or(Decimal(1), 1), d)
3272 self.assertEqual(c.logical_or(1, Decimal(1)), d)
3277 Decimal = self.decimal.Decimal
3278 Context = self.decimal.Context
3281 d = c.logical_xor(Decimal(1), Decimal(1))
3283 self.assertEqual(c.logical_xor(Decimal(1), 1), d)
3284 self.assertEqual(c.logical_xor(1, Decimal(1)), d)
3289 Decimal = self.decimal.Decimal
3290 Context = self.decimal.Context
3293 d = c.max(Decimal(1), Decimal(2))
3295 self.assertEqual(c.max(Decimal(1), 2), d)
3296 self.assertEqual(c.max(1, Decimal(2)), d)
3301 Decimal = self.decimal.Decimal
3302 Context = self.decimal.Context
3305 d = c.max_mag(Decimal(1), Decimal(2))
3307 self.assertEqual(c.max_mag(Decimal(1), 2), d)
3308 self.assertEqual(c.max_mag(1, Decimal(2)), d)
3313 Decimal = self.decimal.Decimal
3314 Context = self.decimal.Context
3317 d = c.min(Decimal(1), Decimal(2))
3319 self.assertEqual(c.min(Decimal(1), 2), d)
3320 self.assertEqual(c.min(1, Decimal(2)), d)
3325 Decimal = self.decimal.Decimal
3326 Context = self.decimal.Context
3329 d = c.min_mag(Decimal(1), Decimal(2))
3331 self.assertEqual(c.min_mag(Decimal(1), 2), d)
3332 self.assertEqual(c.min_mag(1, Decimal(2)), d)
3337 Decimal = self.decimal.Decimal
3338 Context = self.decimal.Context
3341 d = c.minus(Decimal(10))
3346 Decimal = self.decimal.Decimal
3347 Context = self.decimal.Context
3350 d = c.multiply(Decimal(1), Decimal(2))
3352 self.assertEqual(c.multiply(Decimal(1), 2), d)
3353 self.assertEqual(c.multiply(1, Decimal(2)), d)
3358 Decimal = self.decimal.Decimal
3359 Context = self.decimal.Context
3362 d = c.next_minus(Decimal(10))
3367 Decimal = self.decimal.Decimal
3368 Context = self.decimal.Context
3371 d = c.next_plus(Decimal(10))
3376 Decimal = self.decimal.Decimal
3377 Context = self.decimal.Context
3380 d = c.next_toward(Decimal(1), Decimal(2))
3382 self.assertEqual(c.next_toward(Decimal(1), 2), d)
3383 self.assertEqual(c.next_toward(1, Decimal(2)), d)
3388 Decimal = self.decimal.Decimal
3389 Context = self.decimal.Context
3392 d = c.normalize(Decimal(10))
3397 Decimal = self.decimal.Decimal
3398 Context = self.decimal.Context
3401 self.assertEqual(c.number_class(123), c.number_class(Decimal(123)))
3402 self.assertEqual(c.number_class(0), c.number_class(Decimal(0)))
3403 self.assertEqual(c.number_class(-45), c.number_class(Decimal(-45)))
3406 Decimal = self.decimal.Decimal
3407 Context = self.decimal.Context
3410 d = c.plus(Decimal(10))
3415 Decimal = self.decimal.Decimal
3416 Context = self.decimal.Context
3419 d = c.power(Decimal(1), Decimal(4))
3421 self.assertEqual(c.power(Decimal(1), 4), d)
3422 self.assertEqual(c.power(1, Decimal(4)), d)
3423 self.assertEqual(c.power(Decimal(1), Decimal(4)), d)
3429 Decimal = self.decimal.Decimal
3430 Context = self.decimal.Context
3433 d = c.quantize(Decimal(1), Decimal(2))
3435 self.assertEqual(c.quantize(Decimal(1), 2), d)
3436 self.assertEqual(c.quantize(1, Decimal(2)), d)
3441 Decimal = self.decimal.Decimal
3442 Context = self.decimal.Context
3445 d = c.remainder(Decimal(1), Decimal(2))
3447 self.assertEqual(c.remainder(Decimal(1), 2), d)
3448 self.assertEqual(c.remainder(1, Decimal(2)), d)
3453 Decimal = self.decimal.Decimal
3454 Context = self.decimal.Context
3457 d = c.remainder_near(Decimal(1), Decimal(2))
3459 self.assertEqual(c.remainder_near(Decimal(1), 2), d)
3460 self.assertEqual(c.remainder_near(1, Decimal(2)), d)
3465 Decimal = self.decimal.Decimal
3466 Context = self.decimal.Context
3469 d = c.rotate(Decimal(1), Decimal(2))
3471 self.assertEqual(c.rotate(Decimal(1), 2), d)
3472 self.assertEqual(c.rotate(1, Decimal(2)), d)
3477 Decimal = self.decimal.Decimal
3478 Context = self.decimal.Context
3481 d = c.sqrt(Decimal(10))
3486 Decimal = self.decimal.Decimal
3487 Context = self.decimal.Context
3490 d = c.same_quantum(Decimal(1), Decimal(2))
3492 self.assertEqual(c.same_quantum(Decimal(1), 2), d)
3493 self.assertEqual(c.same_quantum(1, Decimal(2)), d)
3498 Decimal = self.decimal.Decimal
3499 Context = self.decimal.Context
3502 d = c.scaleb(Decimal(1), Decimal(2))
3504 self.assertEqual(c.scaleb(Decimal(1), 2), d)
3505 self.assertEqual(c.scaleb(1, Decimal(2)), d)
3510 Decimal = self.decimal.Decimal
3511 Context = self.decimal.Context
3514 d = c.shift(Decimal(1), Decimal(2))
3516 self.assertEqual(c.shift(Decimal(1), 2), d)
3517 self.assertEqual(c.shift(1, Decimal(2)), d)
3522 Decimal = self.decimal.Decimal
3523 Context = self.decimal.Context
3526 d = c.subtract(Decimal(1), Decimal(2))
3528 self.assertEqual(c.subtract(Decimal(1), 2), d)
3529 self.assertEqual(c.subtract(1, Decimal(2)), d)
3534 Decimal = self.decimal.Decimal
3535 Context = self.decimal.Context
3538 d = c.to_eng_string(Decimal(10))
3543 Decimal = self.decimal.Decimal
3544 Context = self.decimal.Context
3547 d = c.to_sci_string(Decimal(10))
3552 Decimal = self.decimal.Decimal
3553 Context = self.decimal.Context
3556 d = c.to_integral_exact(Decimal(10))
3561 Decimal = self.decimal.Decimal
3562 Context = self.decimal.Context
3565 d = c.to_integral_value(Decimal(10))
3571 decimal = C variable in CContextAPItests
3573 decimal = P variable in PyContextAPItests
3581 getcontext = self.decimal.getcontext
3582 localcontext = self.decimal.localcontext
3594 Context = self.decimal.Context
3595 getcontext = self.decimal.getcontext
3596 localcontext = self.decimal.localcontext
3598 localcontext = self.decimal.localcontext
3611 Decimal = self.decimal.Decimal
3612 Context = self.decimal.Context
3613 getcontext = self.decimal.getcontext
3614 localcontext = self.decimal.localcontext
3615 Clamped = self.decimal.Clamped
3616 Overflow = self.decimal.Overflow
3632 self.assertRaises(Overflow, c2.power, Decimal('3.4e200'), 2)
3645 localcontext = self.decimal.localcontext
3657 localcontext = self.decimal.localcontext
3669 Context = self.decimal.Context
3670 localcontext = self.decimal.localcontext
3671 getcontext = self.decimal.getcontext
3672 setcontext = self.decimal.setcontext
3702 decimal = C variable in CContextWithStatement
3704 decimal = P variable in PyContextWithStatement
3711 Decimal = self.decimal.Decimal
3712 Context = self.decimal.Context
3713 Inexact = self.decimal.Inexact
3714 Rounded = self.decimal.Rounded
3715 Underflow = self.decimal.Underflow
3716 Clamped = self.decimal.Clamped
3717 Subnormal = self.decimal.Subnormal
3720 if self.decimal == C:
3732 (context._apply, [Decimal("100E-425000010")]),
3733 (context.sqrt, [Decimal(2)]),
3734 (context.add, [Decimal("1.23456789"), Decimal("9.87654321")]),
3735 (context.multiply, [Decimal("1.23456789"), Decimal("9.87654321")]),
3736 (context.subtract, [Decimal("1.23456789"), Decimal("9.87654321")]),
3775 Context = self.decimal.Context
3776 Inexact = self.decimal.Inexact
3777 Rounded = self.decimal.Rounded
3814 Decimal = self.decimal.Decimal
3815 FloatOperation = self.decimal.FloatOperation
3816 localcontext = self.decimal.localcontext
3824 self.assertEqual(Decimal(7.5), 7.5)
3833 x = Decimal.from_float(7.5)
3850 self.assertRaises(FloatOperation, Decimal, 7.5)
3859 x = Decimal.from_float(7.5)
3867 Decimal = self.decimal.Decimal
3868 Context = self.decimal.Context
3869 FloatOperation = self.decimal.FloatOperation
3870 localcontext = self.decimal.localcontext
3881 small_d = Decimal('0.25')
3882 big_d = Decimal('3.0')
3886 zero_d = Decimal('0.0')
3887 neg_zero_d = Decimal('-0.0')
3891 inf_d = Decimal('Infinity')
3892 neg_inf_d = Decimal('-Infinity')
3919 assert_attr(Decimal('0.1'), 0.1, '__ne__', c, None)
3924 assert_attr(Decimal('NaN'), float('nan'), '__ne__', c, None)
3928 s = set([100.0, Decimal('100.0')])
3934 self.assertRaises(signal, sorted, [1.0, Decimal('10.0')])
3936 s = sorted([10.0, Decimal('10.0')])
3940 b = 10.0 in [Decimal('10.0'), 1.0]
3944 b = 10.0 in {Decimal('10.0'):'a', 1.0:'b'}
3958 Decimal = self.decimal.Decimal
3959 Context = self.decimal.Context
3960 Inexact = self.decimal.Inexact
3961 FloatOperation= self.decimal.FloatOperation
3974 decimal = C variable in CContextFlags
3976 decimal = P variable in PyContextFlags
3982 BasicContext = self.decimal.BasicContext
3983 ExtendedContext = self.decimal.ExtendedContext
3984 getcontext = self.decimal.getcontext
3985 setcontext = self.decimal.setcontext
3986 InvalidOperation = self.decimal.InvalidOperation
3987 DivisionByZero = self.decimal.DivisionByZero
3988 Overflow = self.decimal.Overflow
3989 Underflow = self.decimal.Underflow
3990 Clamped = self.decimal.Clamped
4018 DefaultContext = self.decimal.DefaultContext
4019 BasicContext = self.decimal.BasicContext
4020 ExtendedContext = self.decimal.ExtendedContext
4021 getcontext = self.decimal.getcontext
4022 setcontext = self.decimal.setcontext
4023 InvalidOperation = self.decimal.InvalidOperation
4024 DivisionByZero = self.decimal.DivisionByZero
4025 Overflow = self.decimal.Overflow
4059 decimal = C variable in CSpecialContexts
4061 decimal = P variable in PySpecialContexts
4066 Context = self.decimal.Context
4067 DefaultContext = self.decimal.DefaultContext
4126 decimal = C variable in CContextInputValidation
4128 decimal = P variable in PyContextInputValidation
4133 decimal = self.decimal
4134 Decimal = decimal.Decimal
4135 Context = decimal.Context
4136 Clamped = decimal.Clamped
4137 DivisionByZero = decimal.DivisionByZero
4138 Inexact = decimal.Inexact
4139 Overflow = decimal.Overflow
4140 Rounded = decimal.Rounded
4141 Subnormal = decimal.Subnormal
4142 Underflow = decimal.Underflow
4143 InvalidOperation = decimal.InvalidOperation
4164 flags = {v:(v in flags) for v in OrderedSignals[decimal] + flags}
4168 traps = {v:(v in traps) for v in OrderedSignals[decimal] + traps}
4181 self.assertRaises(InvalidOperation, c.quantize, Decimal('9e2'), 0)
4187 self.assertEqual(c.plus(Decimal('9.9')), 9)
4193 x = c.add(Decimal('1e-99'), Decimal('2.234e-2000'))
4194 self.assertEqual(x, Decimal('0.0'))
4202 self.assertRaises(Overflow, c.add, Decimal('1e99'), Decimal('2.234e2000'))
4203 if self.decimal == C:
4218 x = c.plus(Decimal('1e99'))
4227 for signal in OrderedSignals[decimal]:
4236 for signal in OrderedSignals[decimal]:
4240 decimal = C variable in CContextSubclassing
4242 decimal = P variable in PyContextSubclassing
4270 x = [s for s in dir(C.Decimal(9)) if '__' in s or not s.startswith('_')]
4271 y = [s for s in dir(C.Decimal(9)) if '__' in s or not s.startswith('_')]
4277 Decimal = self.decimal.Decimal
4279 self.assertEqual(Decimal('1234e9999').adjusted(), 10002)
4281 self.assertEqual(Decimal('nan').adjusted(), 0)
4282 self.assertEqual(Decimal('inf').adjusted(), 0)
4285 Decimal = self.decimal.Decimal
4286 getcontext = self.decimal.getcontext
4288 x = Decimal(9).canonical()
4292 x = c.canonical(Decimal(9))
4296 c = self.decimal.DefaultContext.copy()
4304 for sig in OrderedSignals[self.decimal]:
4315 Decimal = self.decimal.Decimal
4316 localcontext = self.decimal.localcontext
4324 self.assertEqual(abs(Decimal("-10")), 10)
4326 self.assertEqual(Decimal("7") + 1, 8)
4328 self.assertEqual(Decimal("10") / 5, 2)
4330 self.assertEqual(Decimal("10") // 7, 1)
4332 self.assertEqual(Decimal("1.2").fma(Decimal("0.01"), 1), 1)
4333 self.assertIs(Decimal("NaN").fma(7, 1).is_nan(), True)
4335 self.assertEqual(pow(Decimal(10), 2, 7), 2)
4337 self.assertEqual(Decimal("1.01").exp(), 3)
4339 self.assertIs(Decimal("0.01").is_normal(), False)
4341 self.assertIs(Decimal("0.01").is_subnormal(), True)
4343 self.assertEqual(Decimal("20").ln(), 3)
4345 self.assertEqual(Decimal("20").log10(), 1)
4347 self.assertEqual(Decimal("580").logb(), 2)
4349 self.assertEqual(Decimal("10").logical_invert(), 1)
4351 self.assertEqual(-Decimal("-10"), 10)
4353 self.assertEqual(Decimal("2") * 4, 8)
4355 self.assertEqual(Decimal("10").next_minus(), 9)
4357 self.assertEqual(Decimal("10").next_plus(), Decimal('2E+1'))
4359 self.assertEqual(Decimal("-10").normalize(), Decimal('-1E+1'))
4361 self.assertEqual(Decimal("10").number_class(), '+Normal')
4363 self.assertEqual(+Decimal("-1"), -1)
4365 self.assertEqual(Decimal("10") % 7, 3)
4367 self.assertEqual(Decimal("10") - 7, 3)
4369 self.assertEqual(Decimal("1.12345").to_integral_exact(), 1)
4372 self.assertTrue(Decimal("1").is_canonical())
4373 self.assertTrue(Decimal("1").is_finite())
4374 self.assertTrue(Decimal("1").is_finite())
4375 self.assertTrue(Decimal("snan").is_snan())
4376 self.assertTrue(Decimal("-1").is_signed())
4377 self.assertTrue(Decimal("0").is_zero())
4378 self.assertTrue(Decimal("0").is_zero())
4384 y = -Decimal(x)
4392 z = y.copy_sign(Decimal(1))
4396 Decimal = self.decimal.Decimal
4397 localcontext = self.decimal.localcontext
4398 InvalidOperation = self.decimal.InvalidOperation
4399 DivisionByZero = self.decimal.DivisionByZero
4402 q, r = divmod(Decimal("10912837129"), 1001)
4403 self.assertEqual(q, Decimal('10901935'))
4404 self.assertEqual(r, Decimal('194'))
4406 q, r = divmod(Decimal("NaN"), 7)
4410 q, r = divmod(Decimal("NaN"), 7)
4415 q, r = divmod(Decimal("inf"), Decimal("inf"))
4420 q, r = divmod(Decimal("inf"), 101)
4425 q, r = divmod(Decimal(0), 0)
4431 q, r = divmod(Decimal(11), 0)
4437 Decimal = self.decimal.Decimal
4438 localcontext = self.decimal.localcontext
4439 Overflow = self.decimal.Overflow
4440 Rounded = self.decimal.Rounded
4445 self.assertEqual(Decimal("1.0") ** 100, Decimal('1.00'))
4453 self.assertEqual(Decimal(10000) ** Decimal("0.5"), Decimal('inf'))
4457 Decimal = self.decimal.Decimal
4458 localcontext = self.decimal.localcontext
4459 InvalidOperation = self.decimal.InvalidOperation
4466 x = Decimal(99).quantize(Decimal("1e1"))
4470 Decimal = self.decimal.Decimal
4471 getcontext = self.decimal.getcontext
4474 self.assertEqual(Decimal("1").radix(), 10)
4478 Decimal = self.decimal.Decimal
4482 self.assertIs(getattr(Decimal("1"), attr)("xyz"), NotImplemented)
4485 # Python3 behavior: round() returns Decimal
4486 Decimal = self.decimal.Decimal
4487 localcontext = self.decimal.localcontext
4492 self.assertEqual(str(Decimal("9.99").__round__()), "10")
4493 self.assertEqual(str(Decimal("9.99e-5").__round__()), "0")
4494 self.assertEqual(str(Decimal("1.23456789").__round__(5)), "1.23457")
4495 self.assertEqual(str(Decimal("1.2345").__round__(10)), "1.2345000000")
4496 self.assertEqual(str(Decimal("1.2345").__round__(-10)), "0E+10")
4498 self.assertRaises(TypeError, Decimal("1.23").__round__, "5")
4499 self.assertRaises(TypeError, Decimal("1.23").__round__, 5, 8)
4502 c = self.decimal.Context()
4506 Decimal = self.decimal.Decimal
4507 localcontext = self.decimal.localcontext
4511 x = Decimal(1221**1271) / 10**3923
4516 Context = self.decimal.Context
4532 decimal = C variable in CCoverage
4534 decimal = P variable in PyCoverage
4537 """Extra functionality in decimal.py"""
4540 # triples giving a format, a Decimal, and the expected result
4541 Decimal = P.Decimal
4558 self.assertEqual(format(Decimal(d), fmt), result)
4561 """White box testing for decimal.py"""
4565 Decimal = P.Decimal
4570 x = Decimal(2**16) ** Decimal("-0.5")
4571 self.assertEqual(x, Decimal('0.00390625'))
4573 x = Decimal(2**16) ** Decimal("-0.6")
4574 self.assertEqual(x, Decimal('0.0012885819'))
4576 x = Decimal("256e7") ** Decimal("-0.5")
4578 x = Decimal(152587890625) ** Decimal('-0.0625')
4579 self.assertEqual(x, Decimal("0.2"))
4581 x = Decimal("152587890625e7") ** Decimal('-0.0625')
4583 x = Decimal(5**2659) ** Decimal('-0.0625')
4586 x = Decimal("152587890625") ** Decimal('-0.5')
4588 x = Decimal(2**578) ** Decimal("-0.5")
4592 Decimal = P.Decimal
4600 d1 = Decimal('-25e55')
4601 b1 = Decimal('-25e55')
4602 d2 = Decimal('33e+33')
4603 b2 = Decimal('33e+33')
4620 Decimal(d1)
4670 Decimal = P.Decimal
4672 d = Decimal(45)
4673 e = Decimal(d)
4679 Decimal = P.Decimal
4683 x = Decimal("NaN")._rescale(3, ROUND_UP)
4688 Decimal = P.Decimal
4690 self.assertRaises(ValueError, Decimal("3.1234")._round, 0, ROUND_UP)
4697 # issue 8786: Add support for IEEE 754 contexts to decimal module.
4783 Decimal = C.Decimal
4794 y = Decimal(a) ** Decimal(b)
4798 self.assertRaises(TypeError, C.Decimal, 9, "xyz")
4802 Decimal = C.Decimal
4808 self.assertRaises(InvalidOperation, Decimal,
5044 Decimal = C.Decimal
5053 self.assertRaises(InvalidOperation, Decimal("1.23").__round__,
5055 self.assertRaises(InvalidOperation, Decimal("1.23").__round__,
5057 self.assertRaises(InvalidOperation, Decimal("1").__round__,
5059 self.assertRaises(C.InvalidOperation, Decimal("1").__round__,
5061 self.assertRaises(OverflowError, Decimal("1.23").__round__,
5063 self.assertRaises(OverflowError, Decimal("1.23").__round__,
5068 Decimal = C.Decimal
5071 self.assertRaises(TypeError, Decimal(1).__format__, "=10.10", [], 9)
5072 self.assertRaises(TypeError, Decimal(1).__format__, "=10.10", 9)
5073 self.assertRaises(TypeError, Decimal(1).__format__, [])
5075 self.assertRaises(ValueError, Decimal(1).__format__, "<>=10.10")
5077 self.assertRaises(ValueError, Decimal("1.23456789").__format__,
5081 Decimal = C.Decimal
5085 x = Decimal(10)
5102 x = Decimal("99999999999999999999999999.9").to_integral_value(ROUND_UP)
5103 self.assertEqual(x, Decimal('100000000000000000000000000'))
5105 x = Decimal("99999999999999999999999999.9").to_integral_exact(ROUND_UP)
5106 self.assertEqual(x, Decimal('100000000000000000000000000'))
5109 self.assertRaises(Inexact, Decimal("999.9").to_integral_exact, ROUND_UP)
5113 Decimal = C.Decimal
5119 self.assertEqual(Decimal('9.99e10').to_eng_string(), '99.9E+9')
5121 self.assertRaises(TypeError, pow, Decimal(1), 2, "3")
5122 self.assertRaises(TypeError, Decimal(9).number_class, "x", "y")
5123 self.assertRaises(TypeError, Decimal(9).same_quantum, 3, "x", "y")
5127 Decimal("1.23456789").quantize, Decimal('1e-100000'), []
5131 Decimal("1.23456789").quantize, Decimal('1e-100000'), getcontext()
5135 Decimal("1.23456789").quantize, Decimal('1e-100000'), 10
5139 Decimal("1.23456789").quantize, Decimal('1e-100000'), ROUND_UP, 1000
5146 self.assertRaises(TypeError, c.copy_sign, Decimal(1), "x", "y")
5152 self.assertEqual(str(c.canonical(Decimal(200))), '200')
5156 self.assertRaises(DivisionByZero, Decimal(9).__divmod__, 0)
5162 self.assertRaises(InvalidOperation, Decimal(9).__divmod__, 0)
5168 self.assertRaises(InvalidOperation, pow, Decimal(1000), 1, 501)
5171 Decimal = C.Decimal
5174 x = Decimal("10001111111")
5361 Decimal = C.Decimal
5372 return Decimal(x).__format__(fmt, override)
5398 Decimal = C.Decimal
5408 self.assertRaises(InvalidOperation, Decimal, x)
5411 self.assertRaises(InvalidOperation, Decimal, x)
5415 self.assertRaises(InvalidOperation, Decimal, x)
5419 self.assertRaises(InvalidOperation, Decimal, x)
5422 Decimal = C.Decimal
5437 self.assertRaises(InvalidOperation, Decimal, x)
5441 self.assertRaises(InvalidOperation, Decimal, x)
5446 self.assertRaises(InvalidOperation, Decimal, x)
5450 self.assertRaises(InvalidOperation, Decimal, x)
5455 self.assertRaises(OverflowError, Decimal, x)
5459 self.assertRaises(OverflowError, Decimal, x)
5463 self.assertEqual(str(Decimal(x)), '-sNaN')
5465 self.assertEqual(str(Decimal(x)), '-sNaN')
5467 self.assertEqual(str(Decimal(x)), '-sNaN1')
5470 Decimal = C.Decimal
5473 self.assertGreater(Decimal(0).__sizeof__(), 0)
5475 x = Decimal(10**(19*24)).__sizeof__()
5476 y = Decimal(10**(19*25)).__sizeof__()
5479 x = Decimal(10**(9*24)).__sizeof__()
5480 y = Decimal(10**(9*25)).__sizeof__()
5484 Decimal = C.Decimal
5508 self.assertEqual(Decimal.from_float(cls(101.1)),
5509 Decimal.from_float(101.1))
5529 Decimal = C.Decimal
5537 self.assertEqual(Decimal(0).exp(), 1)
5538 self.assertEqual(Decimal(1).ln(), 0)
5539 self.assertEqual(Decimal(1).log10(), 0)
5540 self.assertEqual(Decimal(10**2).log10(), 2)
5541 self.assertEqual(Decimal(10**223).log10(), 223)
5542 self.assertEqual(Decimal(10**19).logb(), 19)
5543 self.assertEqual(Decimal(4).sqrt(), 2)
5544 self.assertEqual(Decimal("40E9").sqrt(), Decimal('2.0E+5'))
5545 self.assertEqual(divmod(Decimal(10), 3), (3, 1))
5546 self.assertEqual(Decimal(10) // 3, 3)
5547 self.assertEqual(Decimal(4) / 2, 2)
5548 self.assertEqual(Decimal(400) ** -1, Decimal('0.0025'))
5562 if (attr == 'Decimal' or attr == 'Context' or
5590 pdict = {C: {'other': C.Decimal(1),
5591 'third': C.Decimal(1),
5592 'x': C.Decimal(1),
5593 'y': C.Decimal(1),
5594 'z': C.Decimal(1),
5595 'a': C.Decimal(1),
5596 'b': C.Decimal(1),
5597 'c': C.Decimal(1),
5598 'exp': C.Decimal(1),
5599 'modulo': C.Decimal(1),
5604 P: {'other': P.Decimal(1),
5605 'third': P.Decimal(1),
5606 'a': P.Decimal(1),
5607 'b': P.Decimal(1),
5608 'c': P.Decimal(1),
5609 'exp': P.Decimal(1),
5610 'modulo': P.Decimal(1),
5664 if ty == 'Decimal':
5684 doit('Decimal')
5719 Runs all arithmetic tests if arith is True or if the "decimal" resource
5726 TEST_ALL = arith if arith is not None else is_resource_enabled('decimal')
5753 savedecimal = sys.modules['decimal']
5755 sys.modules['decimal'] = C
5757 sys.modules['decimal'] = P
5759 sys.modules['decimal'] = savedecimal
5766 if not orig_sys_decimal is sys.modules['decimal']:
5768 "sys.modules['decimal'].")