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
52 C = import_fresh_module('decimal', fresh=['_decimal'])
53 P = import_fresh_module('decimal', blocked=['_decimal'])
54 import decimal as orig_sys_decimal
56 # fractions module must import the correct decimal module.
58 sys.modules['decimal'] = P
60 sys.modules['decimal'] = C
62 sys.modules['decimal'] = orig_sys_decimal
136 """Class which tests the Decimal class against the IBM test cases."""
139 self.context = self.decimal.Context()
140 self.readcontext = self.decimal.Context()
155 # Decimal behaves differently from decNumber for these testcases so these
181 if self.decimal == C:
201 # Name adapter to be able to change the Decimal and Context
252 self.ErrorNames = {'clamped' : self.decimal.Clamped,
253 'conversion_syntax' : self.decimal.InvalidOperation,
254 'division_by_zero' : self.decimal.DivisionByZero,
255 'division_impossible' : self.decimal.InvalidOperation,
256 'division_undefined' : self.decimal.InvalidOperation,
257 'inexact' : self.decimal.Inexact,
258 'invalid_context' : self.decimal.InvalidOperation,
259 'invalid_operation' : self.decimal.InvalidOperation,
260 'overflow' : self.decimal.Overflow,
261 'rounded' : self.decimal.Rounded,
262 'subnormal' : self.decimal.Subnormal,
263 'underflow' : self.decimal.Underflow}
266 # Decimal instance.
285 if self.decimal == C and self.decimal.MAX_EMAX == 425000000:
291 return self.decimal.Decimal(v, context)
303 except self.decimal.DecimalException as exception:
358 raise self.decimal.InvalidOperation
377 for exception in Signals[self.decimal]:
399 except Signals[self.decimal] as e:
419 except Signals[self.decimal] as e:
427 ordered_errors = [e for e in OrderedSignals[self.decimal] if e in theirexceptions]
434 except Signals[self.decimal] as e:
450 except Signals[self.decimal] as error:
468 return [e for e in Signals[self.decimal] if self.context.flags[e]]
471 if self.decimal == C and self.decimal.MAX_PREC == 425000000:
478 if self.decimal == C and self.decimal.MAX_PREC == 425000000:
483 if self.decimal == C and self.decimal.MAX_PREC == 425000000:
491 decimal = C variable in CIBMTestCases
493 decimal = P variable in PyIBMTestCases
495 # The following classes test the behaviour of Decimal according to PEP 327
498 '''Unit tests for Explicit Construction cases of Decimal.'''
501 Decimal = self.decimal.Decimal
502 self.assertEqual(Decimal(), Decimal("0"))
505 Decimal = self.decimal.Decimal
506 self.assertRaises(TypeError, Decimal, None)
509 Decimal = self.decimal.Decimal
512 d = Decimal(45)
516 d = Decimal(500000123)
520 d = Decimal(-45)
524 d = Decimal(0)
532 d = Decimal(i)
536 Decimal = self.decimal.Decimal
537 InvalidOperation = self.decimal.InvalidOperation
538 localcontext = self.decimal.localcontext
541 self.assertEqual(str(Decimal('')), 'NaN')
544 self.assertEqual(str(Decimal('45')), '45')
547 self.assertEqual(str(Decimal('45.34')), '45.34')
550 self.assertEqual(str(Decimal('45e2')), '4.5E+3')
553 self.assertEqual(str(Decimal('ugly')), 'NaN')
556 self.assertEqual(str(Decimal('1.3E4 \n')), '1.3E+4')
557 self.assertEqual(str(Decimal(' -7.89')), '-7.89')
558 self.assertEqual(str(Decimal(" 3.45679 ")), '3.45679')
561 self.assertEqual(str(Decimal('1_3.3e4_0')), '1.33E+41')
562 self.assertEqual(str(Decimal('1_0_0_0')), '1000')
567 self.assertEqual(str(Decimal(lead + '9.311E+28' + trail)),
573 self.assertRaises(InvalidOperation, Decimal, "xyz")
575 self.assertRaises(TypeError, Decimal, "1234", "x", "y")
578 self.assertRaises(InvalidOperation, Decimal, "1\u00a02\u00a03")
579 self.assertRaises(InvalidOperation, Decimal, "\u00a01\u00a02\u00a0")
582 self.assertRaises(InvalidOperation, Decimal, "\u00a0")
583 self.assertRaises(InvalidOperation, Decimal, "\u00a0\u00a0")
586 self.assertRaises(InvalidOperation, Decimal, "12\u00003")
589 self.assertRaises(InvalidOperation, Decimal, "1_2_\u00003")
596 Decimal = self.decimal.Decimal
597 context = self.decimal.Context()
600 self.assertEqual(str(Decimal(s)), '9.999999')
604 Decimal = self.decimal.Decimal
607 d = Decimal( (0, (0,), 0) )
611 d = Decimal( (1, (4, 5), 0) )
615 d = Decimal( (0, (4, 5, 3, 4), -2) )
619 d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
623 d = Decimal( (0, (), "F") )
627 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1)) )
630 self.assertRaises(ValueError, Decimal, (8, (4, 3, 4, 9, 1), 2) )
631 self.assertRaises(ValueError, Decimal, (0., (4, 3, 4, 9, 1), 2) )
632 self.assertRaises(ValueError, Decimal, (Decimal(1), (4, 3, 4, 9, 1), 2))
635 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), 'wrong!') )
636 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), 0.) )
637 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), '1') )
640 self.assertRaises(ValueError, Decimal, (1, "xyz", 2) )
641 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, None, 1), 2) )
642 self.assertRaises(ValueError, Decimal, (1, (4, -3, 4, 9, 1), 2) )
643 self.assertRaises(ValueError, Decimal, (1, (4, 10, 4, 9, 1), 2) )
644 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 'a', 1), 2) )
647 Decimal = self.decimal.Decimal
649 d = Decimal([0, [0], 0])
652 d = Decimal([1, [4, 3, 4, 9, 1, 3, 5, 3, 4], -25])
655 d = Decimal([1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25])
658 d = Decimal((1, [4, 3, 4, 9, 1, 3, 5, 3, 4], -25))
662 Decimal = self.decimal.Decimal
664 self.assertIs(bool(Decimal(0)), False)
665 self.assertIs(bool(Decimal(1)), True)
666 self.assertEqual(Decimal(False), Decimal(0))
667 self.assertEqual(Decimal(True), Decimal(1))
670 Decimal = self.decimal.Decimal
673 d = Decimal(45)
674 e = Decimal(d)
678 d = Decimal(500000123)
679 e = Decimal(d)
683 d = Decimal(-45)
684 e = Decimal(d)
688 d = Decimal(0)
689 e = Decimal(d)
695 Decimal = self.decimal.Decimal
697 r = Decimal(0.1)
698 self.assertEqual(type(r), Decimal)
701 self.assertTrue(Decimal(float('nan')).is_qnan())
702 self.assertTrue(Decimal(float('inf')).is_infinite())
703 self.assertTrue(Decimal(float('-inf')).is_infinite())
704 self.assertEqual(str(Decimal(float('nan'))),
705 str(Decimal('NaN')))
706 self.assertEqual(str(Decimal(float('inf'))),
707 str(Decimal('Infinity')))
708 self.assertEqual(str(Decimal(float('-inf'))),
709 str(Decimal('-Infinity')))
710 self.assertEqual(str(Decimal(float('-0.0'))),
711 str(Decimal('-0')))
714 self.assertEqual(x, float(Decimal(x))) # roundtrip
717 Decimal = self.decimal.Decimal
718 InvalidOperation = self.decimal.InvalidOperation
719 Rounded = self.decimal.Rounded
721 nc = copy.copy(self.decimal.getcontext())
725 d = Decimal()
735 self.assertIsInstance(d, Decimal)
740 d = Decimal('456789')
750 d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
755 # from Decimal
756 prevdec = Decimal(500000123)
757 d = Decimal(prevdec)
769 self.assertTrue(isinstance(d, Decimal))
795 Decimal('NaN12345'))
802 self.assertEqual(str(nc.create_decimal(Decimal('NaN12345'))), 'NaN')
807 Decimal = self.decimal.Decimal
809 nc = self.decimal.Context()
811 self.assertEqual(type(r), Decimal)
830 Decimal = self.decimal.Decimal
838 self.assertEqual(str(Decimal(input)), expected)
841 decimal = C variable in CExplicitConstructionTest
843 decimal = P variable in PyExplicitConstructionTest
846 '''Unit tests for Implicit Construction cases of Decimal.'''
849 Decimal = self.decimal.Decimal
850 self.assertRaises(TypeError, eval, 'Decimal(5) + None', locals())
853 Decimal = self.decimal.Decimal
856 self.assertEqual(str(Decimal(5) + 45), '50')
858 self.assertEqual(Decimal(5) + 123456789000, Decimal(123456789000))
861 Decimal = self.decimal.Decimal
862 self.assertRaises(TypeError, eval, 'Decimal(5) + "3"', locals())
865 Decimal = self.decimal.Decimal
866 self.assertRaises(TypeError, eval, 'Decimal(5) + 2.2', locals())
869 Decimal = self.decimal.Decimal
870 self.assertEqual(Decimal(5) + Decimal(45), Decimal(50))
873 Decimal = self.decimal.Decimal
894 self.assertEqual(divmod(E(), Decimal(10)), 'divmod 10')
895 self.assertEqual(divmod(Decimal(10), E()), '10 rdivmod')
896 self.assertEqual(eval('Decimal(10) < E()'), 'gt 10')
897 self.assertEqual(eval('Decimal(10) > E()'), 'lt 10')
898 self.assertEqual(eval('Decimal(10) <= E()'), 'ge 10')
899 self.assertEqual(eval('Decimal(10) >= E()'), 'le 10')
900 self.assertEqual(eval('Decimal(10) == E()'), 'eq 10')
901 self.assertEqual(eval('Decimal(10) != E()'), 'ne 10')
917 self.assertEqual(eval('E()' + sym + 'Decimal(10)'),
919 self.assertEqual(eval('Decimal(10)' + sym + 'E()'),
923 decimal = C variable in CImplicitConstructionTest
925 decimal = P variable in PyImplicitConstructionTest
930 Decimal = self.decimal.Decimal
932 # triples giving a format, a Decimal, and the expected result
968 ('.0f', '0', '0'), # no decimal point
1083 self.assertEqual(format(Decimal(d), fmt), result)
1086 self.assertRaises(TypeError, Decimal(1).__format__, b'-020')
1089 Decimal = self.decimal.Decimal
1097 return ''.join([chr(x) for x in lst]) if self.decimal == C else lst
1100 if self.decimal == C:
1101 return Decimal(x).__format__(fmt, override)
1103 return Decimal(x).__format__(fmt, _localeconv=override)
1136 self.assertEqual(get_fmt(Decimal('12.7'), en_US), '12.7')
1137 self.assertEqual(get_fmt(Decimal('12.7'), fr_FR), '12,7')
1138 self.assertEqual(get_fmt(Decimal('12.7'), ru_RU), '12,7')
1139 self.assertEqual(get_fmt(Decimal('12.7'), crazy), '1-2&7')
1173 # wide char separator and decimal point
1174 self.assertEqual(get_fmt(Decimal('-1.5'), dotsep_wide, '020n'),
1179 # locale with wide char separator and decimal point
1180 Decimal = self.decimal.Decimal
1185 self.skipTest('inappropriate decimal point separator '
1191 self.assertEqual(format(Decimal('100000000.123'), 'n'),
1195 class A(self.decimal.Decimal):
1199 self.assertEqual(self.decimal.Decimal, a.a_type)
1202 self.assertEqual(self.decimal.Decimal, a.a_type)
1205 decimal = C variable in CFormatTest
1207 decimal = P variable in PyFormatTest
1213 Decimal = self.decimal.Decimal
1215 d1 = Decimal('-11.1')
1216 d2 = Decimal('22.2')
1219 self.assertEqual(d1+d2, Decimal('11.1'))
1220 self.assertEqual(d2+d1, Decimal('11.1'))
1224 self.assertEqual(c, Decimal('-6.1'))
1229 self.assertEqual(c, Decimal('-6.1'))
1232 #inline with decimal
1234 self.assertEqual(d1, Decimal('11.1'))
1238 self.assertEqual(d1, Decimal('16.1'))
1241 Decimal = self.decimal.Decimal
1243 d1 = Decimal('-11.1')
1244 d2 = Decimal('22.2')
1247 self.assertEqual(d1-d2, Decimal('-33.3'))
1248 self.assertEqual(d2-d1, Decimal('33.3'))
1252 self.assertEqual(c, Decimal('-16.1'))
1257 self.assertEqual(c, Decimal('16.1'))
1260 #inline with decimal
1262 self.assertEqual(d1, Decimal('-33.3'))
1266 self.assertEqual(d1, Decimal('-38.3'))
1269 Decimal = self.decimal.Decimal
1271 d1 = Decimal('-5')
1272 d2 = Decimal('3')
1275 self.assertEqual(d1*d2, Decimal('-15'))
1276 self.assertEqual(d2*d1, Decimal('-15'))
1280 self.assertEqual(c, Decimal('-25'))
1285 self.assertEqual(c, Decimal('-25'))
1288 #inline with decimal
1290 self.assertEqual(d1, Decimal('-15'))
1294 self.assertEqual(d1, Decimal('-75'))
1297 Decimal = self.decimal.Decimal
1299 d1 = Decimal('-5')
1300 d2 = Decimal('2')
1303 self.assertEqual(d1/d2, Decimal('-2.5'))
1304 self.assertEqual(d2/d1, Decimal('-0.4'))
1308 self.assertEqual(c, Decimal('-1.25'))
1313 self.assertEqual(c, Decimal('-0.8'))
1316 #inline with decimal
1318 self.assertEqual(d1, Decimal('-2.5'))
1322 self.assertEqual(d1, Decimal('-0.625'))
1325 Decimal = self.decimal.Decimal
1327 d1 = Decimal('5')
1328 d2 = Decimal('2')
1331 self.assertEqual(d1//d2, Decimal('2'))
1332 self.assertEqual(d2//d1, Decimal('0'))
1336 self.assertEqual(c, Decimal('1'))
1341 self.assertEqual(c, Decimal('1'))
1344 #inline with decimal
1346 self.assertEqual(d1, Decimal('2'))
1350 self.assertEqual(d1, Decimal('1'))
1353 Decimal = self.decimal.Decimal
1355 d1 = Decimal('5')
1356 d2 = Decimal('2')
1359 self.assertEqual(d1**d2, Decimal('25'))
1360 self.assertEqual(d2**d1, Decimal('32'))
1364 self.assertEqual(c, Decimal('625'))
1369 self.assertEqual(c, Decimal('16807'))
1372 #inline with decimal
1374 self.assertEqual(d1, Decimal('25'))
1378 self.assertEqual(d1, Decimal('390625'))
1381 Decimal = self.decimal.Decimal
1383 d1 = Decimal('5')
1384 d2 = Decimal('2')
1387 self.assertEqual(d1%d2, Decimal('1'))
1388 self.assertEqual(d2%d1, Decimal('2'))
1392 self.assertEqual(c, Decimal('1'))
1397 self.assertEqual(c, Decimal('2'))
1400 #inline with decimal
1402 self.assertEqual(d1, Decimal('1'))
1406 self.assertEqual(d1, Decimal('1'))
1409 Decimal = self.decimal.Decimal
1411 d1 = Decimal('5')
1412 d2 = Decimal('2')
1416 self.assertEqual(p, Decimal('2'))
1417 self.assertEqual(q, Decimal('1'))
1423 self.assertEqual(p, Decimal('1'))
1424 self.assertEqual(q, Decimal('1'))
1430 self.assertEqual(p, Decimal('1'))
1431 self.assertEqual(q, Decimal('2'))
1436 Decimal = self.decimal.Decimal
1438 self.assertEqual(+Decimal(45), Decimal(+45)) # +
1439 self.assertEqual(-Decimal(45), Decimal(-45)) # -
1440 self.assertEqual(abs(Decimal(45)), abs(Decimal(-45))) # abs
1450 Decimal = self.decimal.Decimal
1451 InvalidOperation = self.decimal.InvalidOperation
1452 localcontext = self.decimal.localcontext
1454 n = Decimal('NaN')
1455 s = Decimal('sNaN')
1456 i = Decimal('Inf')
1457 f = Decimal('2')
1498 Decimal = self.decimal.Decimal
1500 d = Decimal(1).copy_sign(Decimal(-2))
1501 self.assertEqual(Decimal(1).copy_sign(-2), d)
1502 self.assertRaises(TypeError, Decimal(1).copy_sign, '-2')
1505 decimal = C variable in CArithmeticOperatorsTest
1507 decimal = P variable in PyArithmeticOperatorsTest
1512 Decimal = cls.decimal.Decimal
1513 InvalidOperation = cls.decimal.InvalidOperation
1514 DivisionByZero = cls.decimal.DivisionByZero
1515 Overflow = cls.decimal.Overflow
1516 Underflow = cls.decimal.Underflow
1517 Inexact = cls.decimal.Inexact
1518 getcontext = cls.decimal.getcontext
1519 localcontext = cls.decimal.localcontext
1521 d1 = Decimal(1)
1522 d3 = Decimal(3)
1536 cls.assertRaises(InvalidOperation, c3.compare, d1, Decimal('sNaN'))
1542 cls.assertEqual(test1, Decimal('0.333333333333333333333333'))
1543 cls.assertEqual(test2, Decimal('0.333333333333333333333333'))
1551 Decimal = cls.decimal.Decimal
1552 InvalidOperation = cls.decimal.InvalidOperation
1553 DivisionByZero = cls.decimal.DivisionByZero
1554 Overflow = cls.decimal.Overflow
1555 Underflow = cls.decimal.Underflow
1556 Inexact = cls.decimal.Inexact
1557 getcontext = cls.decimal.getcontext
1558 localcontext = cls.decimal.localcontext
1560 d1 = Decimal(1)
1561 d3 = Decimal(3)
1570 cls.assertRaises(Overflow, c2.multiply, Decimal('1e425000000'), 999)
1576 cls.assertRaises(Underflow, c3.divide, Decimal('1e-425000000'), 999)
1586 cls.assertEqual(test1, Decimal('0.333333333333333333333333'))
1587 cls.assertEqual(test2, Decimal('0.333333333333333333'))
1595 '''Unit tests for thread local contexts in Decimal.'''
1601 DefaultContext = self.decimal.DefaultContext
1603 if self.decimal == C and not self.decimal.HAVE_THREADS:
1628 for sig in Signals[self.decimal]:
1640 decimal = C variable in CThreadingTest
1643 decimal = P variable in PyThreadingTest
1646 '''Unit tests for Usability cases of Decimal.'''
1650 Decimal = self.decimal.Decimal
1652 da = Decimal('23.42')
1653 db = Decimal('23.42')
1654 dc = Decimal('45')
1666 #a Decimal and an int
1671 #a Decimal and uncomparable
1678 a = list(map(Decimal, range(100)))
1685 Decimal = self.decimal.Decimal
1687 da = Decimal('0.25')
1688 db = Decimal('3.0')
1701 self.assertNotEqual(0.1, Decimal('0.1'))
1704 Decimal = self.decimal.Decimal
1706 da = Decimal('0.25')
1707 db = Decimal('3.0')
1724 D = self.decimal.Decimal
1725 F = fractions[self.decimal].Fraction
1726 Context = self.decimal.Context
1727 localcontext = self.decimal.localcontext
1728 InvalidOperation = self.decimal.InvalidOperation
1766 Decimal = self.decimal.Decimal
1768 d = Decimal('43.24')
1776 Decimal = self.decimal.Decimal
1777 localcontext = self.decimal.localcontext
1786 hashit(Decimal(23))
1787 hashit(Decimal('Infinity'))
1788 hashit(Decimal('-Infinity'))
1789 hashit(Decimal('nan123'))
1790 hashit(Decimal('-NaN'))
1792 test_values = [Decimal(sign*(2**m + n))
1798 Decimal("-1"), # ==> -2
1799 Decimal("-0"), # zeros
1800 Decimal("0.00"),
1801 Decimal("-0.000"),
1802 Decimal("0E10"),
1803 Decimal("-0E12"),
1804 Decimal("10.0"), # negative exponent
1805 Decimal("-23.00000"),
1806 Decimal("1230E100"), # positive exponent
1807 Decimal("-4.5678E50"),
1810 Decimal(2**64 + 2**32 - 1),
1813 Decimal("1.634E100"),
1814 Decimal("90.697E100"),
1815 Decimal("188.83E100"),
1816 Decimal("1652.9E100"),
1817 Decimal("56531E100"),
1824 # check that the hashes of a Decimal float match when they
1830 d = Decimal(s)
1836 x = Decimal("123456789.1")
1850 self.assertEqual(hashit(Decimal(x)), hashit(x))
1853 Decimal = self.decimal.Decimal
1854 self.assertRaises(TypeError, hash, Decimal('sNaN'))
1855 value = Decimal('NaN')
1860 class D(Decimal, H):
1866 Decimal = self.decimal.Decimal
1868 d1 = Decimal('15.32')
1869 d2 = Decimal('28.5')
1879 #between Decimal and int
1886 Decimal = self.decimal.Decimal
1889 self.assertFalse(Decimal(0))
1891 self.assertTrue(Decimal('0.372'))
1895 Decimal = self.decimal.Decimal
1897 d = Decimal('15.32')
1899 self.assertEqual(repr(d), "Decimal('15.32')") # repr
1903 Decimal = self.decimal.Decimal
1905 d1 = Decimal('66')
1906 d2 = Decimal('15.32')
1929 self.assertEqual(math.floor(Decimal(d)), i)
1930 self.assertRaises(ValueError, math.floor, Decimal('-NaN'))
1931 self.assertRaises(ValueError, math.floor, Decimal('sNaN'))
1932 self.assertRaises(ValueError, math.floor, Decimal('NaN123'))
1933 self.assertRaises(OverflowError, math.floor, Decimal('Inf'))
1934 self.assertRaises(OverflowError, math.floor, Decimal('-Inf'))
1949 self.assertEqual(math.ceil(Decimal(d)), i)
1950 self.assertRaises(ValueError, math.ceil, Decimal('-NaN'))
1951 self.assertRaises(ValueError, math.ceil, Decimal('sNaN'))
1952 self.assertRaises(ValueError, math.ceil, Decimal('NaN123'))
1953 self.assertRaises(OverflowError, math.ceil, Decimal('Inf'))
1954 self.assertRaises(OverflowError, math.ceil, Decimal('-Inf'))
1976 self.assertEqual(round(Decimal(d)), i)
1977 self.assertRaises(ValueError, round, Decimal('-NaN'))
1978 self.assertRaises(ValueError, round, Decimal('sNaN'))
1979 self.assertRaises(ValueError, round, Decimal('NaN123'))
1980 self.assertRaises(OverflowError, round, Decimal('Inf'))
1981 self.assertRaises(OverflowError, round, Decimal('-Inf'))
2002 self.assertEqual(str(round(Decimal(d), n)), r)
2005 # Test conversions of decimal NANs to float.
2007 Decimal = self.decimal.Decimal
2009 f = float(Decimal(s))
2015 Decimal = self.decimal.Decimal
2017 d = Decimal(s)
2021 Decimal = self.decimal.Decimal
2024 d = Decimal( (0, (0,), 0) )
2028 d = Decimal( (1, (4, 5), 0) )
2032 d = Decimal( (0, (4, 5, 3, 4), -2) )
2036 d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
2040 Decimal = self.decimal.Decimal
2043 d = Decimal(0)
2047 d = Decimal(-45)
2051 d = Decimal("-4.34913534E-17")
2054 # The '0' coefficient is implementation specific to decimal.py.
2056 d = Decimal("Infinity")
2060 d = Decimal( (0, (0, 0, 4, 0, 5, 3, 4), -2) )
2062 d = Decimal( (1, (0, 0, 0), 37) )
2064 d = Decimal( (1, (), 37) )
2068 d = Decimal( (0, (0, 0, 4, 0, 5, 3, 4), 'n') )
2070 d = Decimal( (1, (0, 0, 0), 'N') )
2072 d = Decimal( (1, (), 'n') )
2075 # For infinities, decimal.py has always silently accepted any
2077 d = Decimal( (0, (0,), 'F') )
2079 d = Decimal( (0, (4, 5, 3, 4), 'F') )
2081 d = Decimal( (1, (0, 2, 7, 1), 'F') )
2085 Decimal = self.decimal.Decimal
2089 Decimal.as_integer_ratio, Decimal('inf'))
2091 Decimal.as_integer_ratio, Decimal('-inf'))
2093 Decimal.as_integer_ratio, Decimal('-nan'))
2095 Decimal.as_integer_ratio, Decimal('snan123'))
2100 d = Decimal('%s%dE%d' % (sign, coeff, exp))
2115 self.assertEqual(Decimal(p) / Decimal(q), d)
2118 # Different behaviours when subclassing Decimal
2119 Decimal = self.decimal.Decimal
2121 class MyDecimal(Decimal):
2127 self.assertIs(type(d), Decimal)
2130 self.assertIs(type(d), Decimal)
2140 # Decimal(Decimal)
2141 d = Decimal('1.0')
2142 x = Decimal(d)
2143 self.assertIs(type(x), Decimal)
2146 # MyDecimal(Decimal)
2152 # Decimal(MyDecimal)
2153 x = Decimal(m)
2154 self.assertIs(type(x), Decimal)
2165 Decimal = self.decimal.Decimal
2166 getcontext = self.decimal.getcontext
2170 self.assertEqual(str(Decimal(0).sqrt()),
2171 str(c.sqrt(Decimal(0))))
2174 Decimal = self.decimal.Decimal
2175 Context = self.decimal.Context
2176 localcontext = self.decimal.localcontext
2177 InvalidOperation = self.decimal.InvalidOperation
2178 DivisionByZero = self.decimal.DivisionByZero
2179 Overflow = self.decimal.Overflow
2180 Underflow = self.decimal.Underflow
2181 Subnormal = self.decimal.Subnormal
2182 Inexact = self.decimal.Inexact
2183 Rounded = self.decimal.Rounded
2184 Clamped = self.decimal.Clamped
2191 x = Decimal("111")
2192 y = Decimal("1e9999")
2193 z = Decimal("1e-9999")
2212 self.assertRaises(InvalidOperation, Decimal(-1).ln, context=None)
2220 self.assertRaises(InvalidOperation, Decimal(-1).log10, context=None)
2225 self.assertRaises(DivisionByZero, Decimal(0).logb, context=None)
2235 self.assertRaises(InvalidOperation, Decimal('sNaN').next_minus, context=None)
2240 self.assertRaises(InvalidOperation, Decimal('sNaN').next_plus, context=None)
2268 ans = str(x.compare(Decimal('Nan891287828'), context=None))
2270 self.assertRaises(InvalidOperation, x.compare, Decimal('sNaN'), context=None)
2276 self.assertRaises(InvalidOperation, x.compare_signal, Decimal('NaN'), context=None)
2300 self.assertRaises(InvalidOperation, x.max, Decimal('sNaN'), context=None)
2306 self.assertRaises(InvalidOperation, x.max_mag, Decimal('sNaN'), context=None)
2312 self.assertRaises(InvalidOperation, x.min, Decimal('sNaN'), context=None)
2318 self.assertRaises(InvalidOperation, x.min_mag, Decimal('sNaN'), context=None)
2350 self.assertRaises(Overflow, x.fma, Decimal('1e9999'), 3, context=None)
2356 ans = str(Decimal('1.5').to_integral(rounding=None, context=None))
2359 ans = str(Decimal('1.5').to_integral(rounding=None, context=None))
2361 ans = str(Decimal('1.5').to_integral(rounding=ROUND_UP, context=None))
2364 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral, context=None)
2368 ans = str(Decimal('1.5').to_integral_value(rounding=None, context=None))
2371 ans = str(Decimal('1.5').to_integral_value(rounding=None, context=None))
2373 ans = str(Decimal('1.5').to_integral_value(rounding=ROUND_UP, context=None))
2376 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral_value, context=None)
2380 ans = str(Decimal('1.5').to_integral_exact(rounding=None, context=None))
2383 ans = str(Decimal('1.5').to_integral_exact(rounding=None, context=None))
2385 ans = str(Decimal('1.5').to_integral_exact(rounding=ROUND_UP, context=None))
2388 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral_exact, context=None)
2392 ans = str(Decimal('1.50001').quantize(exp=Decimal('1e-3'), rounding=None, context=None))
2395 ans = str(Decimal('1.50001').quantize(exp=Decimal('1e-3'), rounding=None, context=None))
2397 … ans = str(Decimal('1.50001').quantize(exp=Decimal('1e-3'), rounding=ROUND_UP, context=None))
2400 … self.assertRaises(InvalidOperation, y.quantize, Decimal('1e-10'), rounding=ROUND_UP, context=None)
2413 # Check that methods taking a second Decimal argument will
2414 # always accept an integer in place of a Decimal.
2415 Decimal = self.decimal.Decimal
2417 self.assertEqual(Decimal(4).compare(3),
2418 Decimal(4).compare(Decimal(3)))
2419 self.assertEqual(Decimal(4).compare_signal(3),
2420 Decimal(4).compare_signal(Decimal(3)))
2421 self.assertEqual(Decimal(4).compare_total(3),
2422 Decimal(4).compare_total(Decimal(3)))
2423 self.assertEqual(Decimal(4).compare_total_mag(3),
2424 Decimal(4).compare_total_mag(Decimal(3)))
2425 self.assertEqual(Decimal(10101).logical_and(1001),
2426 Decimal(10101).logical_and(Decimal(1001)))
2427 self.assertEqual(Decimal(10101).logical_or(1001),
2428 Decimal(10101).logical_or(Decimal(1001)))
2429 self.assertEqual(Decimal(10101).logical_xor(1001),
2430 Decimal(10101).logical_xor(Decimal(1001)))
2431 self.assertEqual(Decimal(567).max(123),
2432 Decimal(567).max(Decimal(123)))
2433 self.assertEqual(Decimal(567).max_mag(123),
2434 Decimal(567).max_mag(Decimal(123)))
2435 self.assertEqual(Decimal(567).min(123),
2436 Decimal(567).min(Decimal(123)))
2437 self.assertEqual(Decimal(567).min_mag(123),
2438 Decimal(567).min_mag(Decimal(123)))
2439 self.assertEqual(Decimal(567).next_toward(123),
2440 Decimal(567).next_toward(Decimal(123)))
2441 self.assertEqual(Decimal(1234).quantize(100),
2442 Decimal(1234).quantize(Decimal(100)))
2443 self.assertEqual(Decimal(768).remainder_near(1234),
2444 Decimal(768).remainder_near(Decimal(1234)))
2445 self.assertEqual(Decimal(123).rotate(1),
2446 Decimal(123).rotate(Decimal(1)))
2447 self.assertEqual(Decimal(1234).same_quantum(1000),
2448 Decimal(1234).same_quantum(Decimal(1000)))
2449 self.assertEqual(Decimal('9.123').scaleb(-100),
2450 Decimal('9.123').scaleb(Decimal(-100)))
2451 self.assertEqual(Decimal(456).shift(-1),
2452 Decimal(456).shift(Decimal(-1)))
2454 self.assertEqual(Decimal(-12).fma(Decimal(45), 67),
2455 Decimal(-12).fma(Decimal(45), Decimal(67)))
2456 self.assertEqual(Decimal(-12).fma(45, 67),
2457 Decimal(-12).fma(Decimal(45), Decimal(67)))
2458 self.assertEqual(Decimal(-12).fma(45, Decimal(67)),
2459 Decimal(-12).fma(Decimal(45), Decimal(67)))
2462 decimal = C variable in CUsabilityTest
2464 decimal = P variable in PyUsabilityTest
2469 Decimal = self.decimal.Decimal
2471 self.assertTrue(issubclass(Decimal, numbers.Number))
2472 self.assertFalse(issubclass(Decimal, numbers.Real))
2473 self.assertIsInstance(Decimal(0), numbers.Number)
2474 self.assertNotIsInstance(Decimal(0), numbers.Real)
2478 Decimal = self.decimal.Decimal
2480 savedecimal = sys.modules['decimal']
2483 sys.modules['decimal'] = self.decimal
2484 d = Decimal('-3.141590000')
2491 x = C.Decimal('-3.123e81723')
2492 y = P.Decimal('-3.123e81723')
2494 sys.modules['decimal'] = C
2496 sys.modules['decimal'] = P
2498 self.assertIsInstance(r, P.Decimal)
2501 sys.modules['decimal'] = P
2503 sys.modules['decimal'] = C
2505 self.assertIsInstance(r, C.Decimal)
2508 x = C.Decimal('-3.123e81723').as_tuple()
2509 y = P.Decimal('-3.123e81723').as_tuple()
2511 sys.modules['decimal'] = C
2513 sys.modules['decimal'] = P
2518 sys.modules['decimal'] = P
2520 sys.modules['decimal'] = C
2525 sys.modules['decimal'] = savedecimal
2528 Decimal = self.decimal.Decimal
2533 self.assertEqual(int(Decimal(s)), int(float(s)))
2535 d = Decimal(s)
2537 self.assertEqual(Decimal(int(d)), r)
2539 self.assertRaises(ValueError, int, Decimal('-nan'))
2540 self.assertRaises(ValueError, int, Decimal('snan'))
2541 self.assertRaises(OverflowError, int, Decimal('inf'))
2542 self.assertRaises(OverflowError, int, Decimal('-inf'))
2545 Decimal = self.decimal.Decimal
2550 self.assertEqual(int(Decimal(s)), int(float(s)))
2552 d = Decimal(s)
2554 self.assertEqual(Decimal(math.trunc(d)), r)
2558 Decimal = self.decimal.Decimal
2560 class MyDecimal(Decimal):
2564 self.assertTrue(issubclass(MyDecimal, Decimal))
2578 str(Decimal('NaN')))
2580 str(Decimal('Infinity')))
2582 str(Decimal('-Infinity')))
2589 Decimal = self.decimal.Decimal
2590 Context = self.decimal.Context
2591 Inexact = self.decimal.Inexact
2596 Decimal('3.1415')
2601 Decimal('3.1416')
2610 "Decimal('-0')")
2612 "Decimal('1')")
2614 "Decimal('10')")
2617 Decimal = self.decimal.Decimal
2618 Context = self.decimal.Context
2619 InvalidOperation = self.decimal.InvalidOperation
2623 Decimal('7.335').quantize(Decimal('.01')),
2624 Decimal('7.34')
2627 Decimal('7.335').quantize(Decimal('.01'), rounding=ROUND_DOWN),
2628 Decimal('7.33')
2632 Decimal("10e99999").quantize, Decimal('1e100000'), context=c
2636 d = Decimal("0.871831e800")
2637 x = d.quantize(context=c, exp=Decimal("1e797"), rounding=ROUND_DOWN)
2638 self.assertEqual(x, Decimal('8.71E+799'))
2641 Decimal = self.decimal.Decimal
2643 x = Decimal("9.8182731e181273")
2648 x = Decimal("1")
2657 D = self.decimal.Decimal
2658 Context = self.decimal.Context
2659 localcontext = self.decimal.localcontext
2660 InvalidOperation = self.decimal.InvalidOperation
2661 Overflow = self.decimal.Overflow
2770 decimal = self.decimal
2771 DecimalException = decimal.DecimalException
2772 InvalidOperation = decimal.InvalidOperation
2773 FloatOperation = decimal.FloatOperation
2774 DivisionByZero = decimal.DivisionByZero
2775 Overflow = decimal.Overflow
2776 Underflow = decimal.Underflow
2777 Subnormal = decimal.Subnormal
2778 Inexact = decimal.Inexact
2779 Rounded = decimal.Rounded
2780 Clamped = decimal.Clamped
2802 self.assertTrue(issubclass(decimal.ConversionSyntax, InvalidOperation))
2803 self.assertTrue(issubclass(decimal.DivisionImpossible, InvalidOperation))
2804 self.assertTrue(issubclass(decimal.DivisionUndefined, InvalidOperation))
2805 self.assertTrue(issubclass(decimal.DivisionUndefined, ZeroDivisionError))
2806 self.assertTrue(issubclass(decimal.InvalidContext, InvalidOperation))
2809 decimal = C variable in CPythonAPItests
2811 decimal = P variable in PyPythonAPItests
2816 Context = self.decimal.Context
2817 InvalidOperation = self.decimal.InvalidOperation
2818 DivisionByZero = self.decimal.DivisionByZero
2819 Overflow = self.decimal.Overflow
2840 c = self.decimal.Context()
2855 Context = self.decimal.Context
2857 savedecimal = sys.modules['decimal']
2860 sys.modules['decimal'] = self.decimal
2887 sys.modules['decimal'] = dumper
2898 sys.modules['decimal'] = loader
2911 sys.modules['decimal'] = savedecimal
2914 Decimal = self.decimal.Decimal
2916 self.assertIn(Decimal(10), ['a', 1.0, Decimal(10), (1,2), {}])
2917 self.assertNotIn(Decimal(10), ['a', 1.0, (1,2), {}])
2921 Decimal = self.decimal.Decimal
2922 Context = self.decimal.Context
2941 Context = self.decimal.Context
2946 Decimal = self.decimal.Decimal
2947 Context = self.decimal.Context
2950 d = c.abs(Decimal(-1))
2955 Decimal = self.decimal.Decimal
2956 Context = self.decimal.Context
2959 d = c.add(Decimal(1), Decimal(1))
2961 self.assertEqual(c.add(Decimal(1), 1), d)
2962 self.assertEqual(c.add(1, Decimal(1)), d)
2967 Decimal = self.decimal.Decimal
2968 Context = self.decimal.Context
2971 d = c.compare(Decimal(1), Decimal(1))
2973 self.assertEqual(c.compare(Decimal(1), 1), d)
2974 self.assertEqual(c.compare(1, Decimal(1)), d)
2979 Decimal = self.decimal.Decimal
2980 Context = self.decimal.Context
2983 d = c.compare_signal(Decimal(1), Decimal(1))
2985 self.assertEqual(c.compare_signal(Decimal(1), 1), d)
2986 self.assertEqual(c.compare_signal(1, Decimal(1)), d)
2991 Decimal = self.decimal.Decimal
2992 Context = self.decimal.Context
2995 d = c.compare_total(Decimal(1), Decimal(1))
2997 self.assertEqual(c.compare_total(Decimal(1), 1), d)
2998 self.assertEqual(c.compare_total(1, Decimal(1)), d)
3003 Decimal = self.decimal.Decimal
3004 Context = self.decimal.Context
3007 d = c.compare_total_mag(Decimal(1), Decimal(1))
3009 self.assertEqual(c.compare_total_mag(Decimal(1), 1), d)
3010 self.assertEqual(c.compare_total_mag(1, Decimal(1)), d)
3015 Decimal = self.decimal.Decimal
3016 Context = self.decimal.Context
3019 d = c.copy_abs(Decimal(-1))
3024 Decimal = self.decimal.Decimal
3025 Context = self.decimal.Context
3028 d = c.copy_decimal(Decimal(-1))
3033 Decimal = self.decimal.Decimal
3034 Context = self.decimal.Context
3037 d = c.copy_negate(Decimal(-1))
3042 Decimal = self.decimal.Decimal
3043 Context = self.decimal.Context
3046 d = c.copy_sign(Decimal(1), Decimal(-2))
3048 self.assertEqual(c.copy_sign(Decimal(1), -2), d)
3049 self.assertEqual(c.copy_sign(1, Decimal(-2)), d)
3054 Decimal = self.decimal.Decimal
3055 Context = self.decimal.Context
3058 d = c.divide(Decimal(1), Decimal(2))
3060 self.assertEqual(c.divide(Decimal(1), 2), d)
3061 self.assertEqual(c.divide(1, Decimal(2)), d)
3066 Decimal = self.decimal.Decimal
3067 Context = self.decimal.Context
3070 d = c.divide_int(Decimal(1), Decimal(2))
3072 self.assertEqual(c.divide_int(Decimal(1), 2), d)
3073 self.assertEqual(c.divide_int(1, Decimal(2)), d)
3078 Decimal = self.decimal.Decimal
3079 Context = self.decimal.Context
3082 d = c.divmod(Decimal(1), Decimal(2))
3084 self.assertEqual(c.divmod(Decimal(1), 2), d)
3085 self.assertEqual(c.divmod(1, Decimal(2)), d)
3090 Decimal = self.decimal.Decimal
3091 Context = self.decimal.Context
3094 d = c.exp(Decimal(10))
3099 Decimal = self.decimal.Decimal
3100 Context = self.decimal.Context
3103 d = c.fma(Decimal(2), Decimal(3), Decimal(4))
3105 self.assertEqual(c.fma(Decimal(2), 3, 4), d)
3106 self.assertEqual(c.fma(2, Decimal(3), 4), d)
3107 self.assertEqual(c.fma(2, 3, Decimal(4)), d)
3108 self.assertEqual(c.fma(Decimal(2), Decimal(3), 4), d)
3115 Decimal('Infinity'), Decimal(0), "not a decimal")
3117 Decimal(1), Decimal('snan'), 1.222)
3118 # ... and for Decimal.fma.
3119 self.assertRaises(TypeError, Decimal('Infinity').fma,
3120 Decimal(0), "not a decimal")
3121 self.assertRaises(TypeError, Decimal(1).fma,
3122 Decimal('snan'), 1.222)
3125 Decimal = self.decimal.Decimal
3126 Context = self.decimal.Context
3129 d = c.is_finite(Decimal(10))
3134 Decimal = self.decimal.Decimal
3135 Context = self.decimal.Context
3138 d = c.is_infinite(Decimal(10))
3143 Decimal = self.decimal.Decimal
3144 Context = self.decimal.Context
3147 d = c.is_nan(Decimal(10))
3152 Decimal = self.decimal.Decimal
3153 Context = self.decimal.Context
3156 d = c.is_normal(Decimal(10))
3161 Decimal = self.decimal.Decimal
3162 Context = self.decimal.Context
3165 d = c.is_qnan(Decimal(10))
3170 Decimal = self.decimal.Decimal
3171 Context = self.decimal.Context
3174 d = c.is_signed(Decimal(10))
3179 Decimal = self.decimal.Decimal
3180 Context = self.decimal.Context
3183 d = c.is_snan(Decimal(10))
3188 Decimal = self.decimal.Decimal
3189 Context = self.decimal.Context
3192 d = c.is_subnormal(Decimal(10))
3197 Decimal = self.decimal.Decimal
3198 Context = self.decimal.Context
3201 d = c.is_zero(Decimal(10))
3206 Decimal = self.decimal.Decimal
3207 Context = self.decimal.Context
3210 d = c.ln(Decimal(10))
3215 Decimal = self.decimal.Decimal
3216 Context = self.decimal.Context
3219 d = c.log10(Decimal(10))
3224 Decimal = self.decimal.Decimal
3225 Context = self.decimal.Context
3228 d = c.logb(Decimal(10))
3233 Decimal = self.decimal.Decimal
3234 Context = self.decimal.Context
3237 d = c.logical_and(Decimal(1), Decimal(1))
3239 self.assertEqual(c.logical_and(Decimal(1), 1), d)
3240 self.assertEqual(c.logical_and(1, Decimal(1)), d)
3245 Decimal = self.decimal.Decimal
3246 Context = self.decimal.Context
3249 d = c.logical_invert(Decimal(1000))
3254 Decimal = self.decimal.Decimal
3255 Context = self.decimal.Context
3258 d = c.logical_or(Decimal(1), Decimal(1))
3260 self.assertEqual(c.logical_or(Decimal(1), 1), d)
3261 self.assertEqual(c.logical_or(1, Decimal(1)), d)
3266 Decimal = self.decimal.Decimal
3267 Context = self.decimal.Context
3270 d = c.logical_xor(Decimal(1), Decimal(1))
3272 self.assertEqual(c.logical_xor(Decimal(1), 1), d)
3273 self.assertEqual(c.logical_xor(1, Decimal(1)), d)
3278 Decimal = self.decimal.Decimal
3279 Context = self.decimal.Context
3282 d = c.max(Decimal(1), Decimal(2))
3284 self.assertEqual(c.max(Decimal(1), 2), d)
3285 self.assertEqual(c.max(1, Decimal(2)), d)
3290 Decimal = self.decimal.Decimal
3291 Context = self.decimal.Context
3294 d = c.max_mag(Decimal(1), Decimal(2))
3296 self.assertEqual(c.max_mag(Decimal(1), 2), d)
3297 self.assertEqual(c.max_mag(1, Decimal(2)), d)
3302 Decimal = self.decimal.Decimal
3303 Context = self.decimal.Context
3306 d = c.min(Decimal(1), Decimal(2))
3308 self.assertEqual(c.min(Decimal(1), 2), d)
3309 self.assertEqual(c.min(1, Decimal(2)), d)
3314 Decimal = self.decimal.Decimal
3315 Context = self.decimal.Context
3318 d = c.min_mag(Decimal(1), Decimal(2))
3320 self.assertEqual(c.min_mag(Decimal(1), 2), d)
3321 self.assertEqual(c.min_mag(1, Decimal(2)), d)
3326 Decimal = self.decimal.Decimal
3327 Context = self.decimal.Context
3330 d = c.minus(Decimal(10))
3335 Decimal = self.decimal.Decimal
3336 Context = self.decimal.Context
3339 d = c.multiply(Decimal(1), Decimal(2))
3341 self.assertEqual(c.multiply(Decimal(1), 2), d)
3342 self.assertEqual(c.multiply(1, Decimal(2)), d)
3347 Decimal = self.decimal.Decimal
3348 Context = self.decimal.Context
3351 d = c.next_minus(Decimal(10))
3356 Decimal = self.decimal.Decimal
3357 Context = self.decimal.Context
3360 d = c.next_plus(Decimal(10))
3365 Decimal = self.decimal.Decimal
3366 Context = self.decimal.Context
3369 d = c.next_toward(Decimal(1), Decimal(2))
3371 self.assertEqual(c.next_toward(Decimal(1), 2), d)
3372 self.assertEqual(c.next_toward(1, Decimal(2)), d)
3377 Decimal = self.decimal.Decimal
3378 Context = self.decimal.Context
3381 d = c.normalize(Decimal(10))
3386 Decimal = self.decimal.Decimal
3387 Context = self.decimal.Context
3390 self.assertEqual(c.number_class(123), c.number_class(Decimal(123)))
3391 self.assertEqual(c.number_class(0), c.number_class(Decimal(0)))
3392 self.assertEqual(c.number_class(-45), c.number_class(Decimal(-45)))
3395 Decimal = self.decimal.Decimal
3396 Context = self.decimal.Context
3399 d = c.plus(Decimal(10))
3404 Decimal = self.decimal.Decimal
3405 Context = self.decimal.Context
3408 d = c.power(Decimal(1), Decimal(4))
3410 self.assertEqual(c.power(Decimal(1), 4), d)
3411 self.assertEqual(c.power(1, Decimal(4)), d)
3412 self.assertEqual(c.power(Decimal(1), Decimal(4)), d)
3418 Decimal = self.decimal.Decimal
3419 Context = self.decimal.Context
3422 d = c.quantize(Decimal(1), Decimal(2))
3424 self.assertEqual(c.quantize(Decimal(1), 2), d)
3425 self.assertEqual(c.quantize(1, Decimal(2)), d)
3430 Decimal = self.decimal.Decimal
3431 Context = self.decimal.Context
3434 d = c.remainder(Decimal(1), Decimal(2))
3436 self.assertEqual(c.remainder(Decimal(1), 2), d)
3437 self.assertEqual(c.remainder(1, Decimal(2)), d)
3442 Decimal = self.decimal.Decimal
3443 Context = self.decimal.Context
3446 d = c.remainder_near(Decimal(1), Decimal(2))
3448 self.assertEqual(c.remainder_near(Decimal(1), 2), d)
3449 self.assertEqual(c.remainder_near(1, Decimal(2)), d)
3454 Decimal = self.decimal.Decimal
3455 Context = self.decimal.Context
3458 d = c.rotate(Decimal(1), Decimal(2))
3460 self.assertEqual(c.rotate(Decimal(1), 2), d)
3461 self.assertEqual(c.rotate(1, Decimal(2)), d)
3466 Decimal = self.decimal.Decimal
3467 Context = self.decimal.Context
3470 d = c.sqrt(Decimal(10))
3475 Decimal = self.decimal.Decimal
3476 Context = self.decimal.Context
3479 d = c.same_quantum(Decimal(1), Decimal(2))
3481 self.assertEqual(c.same_quantum(Decimal(1), 2), d)
3482 self.assertEqual(c.same_quantum(1, Decimal(2)), d)
3487 Decimal = self.decimal.Decimal
3488 Context = self.decimal.Context
3491 d = c.scaleb(Decimal(1), Decimal(2))
3493 self.assertEqual(c.scaleb(Decimal(1), 2), d)
3494 self.assertEqual(c.scaleb(1, Decimal(2)), d)
3499 Decimal = self.decimal.Decimal
3500 Context = self.decimal.Context
3503 d = c.shift(Decimal(1), Decimal(2))
3505 self.assertEqual(c.shift(Decimal(1), 2), d)
3506 self.assertEqual(c.shift(1, Decimal(2)), d)
3511 Decimal = self.decimal.Decimal
3512 Context = self.decimal.Context
3515 d = c.subtract(Decimal(1), Decimal(2))
3517 self.assertEqual(c.subtract(Decimal(1), 2), d)
3518 self.assertEqual(c.subtract(1, Decimal(2)), d)
3523 Decimal = self.decimal.Decimal
3524 Context = self.decimal.Context
3527 d = c.to_eng_string(Decimal(10))
3532 Decimal = self.decimal.Decimal
3533 Context = self.decimal.Context
3536 d = c.to_sci_string(Decimal(10))
3541 Decimal = self.decimal.Decimal
3542 Context = self.decimal.Context
3545 d = c.to_integral_exact(Decimal(10))
3550 Decimal = self.decimal.Decimal
3551 Context = self.decimal.Context
3554 d = c.to_integral_value(Decimal(10))
3560 decimal = C variable in CContextAPItests
3562 decimal = P variable in PyContextAPItests
3570 getcontext = self.decimal.getcontext
3571 localcontext = self.decimal.localcontext
3583 Context = self.decimal.Context
3584 getcontext = self.decimal.getcontext
3585 localcontext = self.decimal.localcontext
3587 localcontext = self.decimal.localcontext
3600 Decimal = self.decimal.Decimal
3601 Context = self.decimal.Context
3602 getcontext = self.decimal.getcontext
3603 localcontext = self.decimal.localcontext
3604 Clamped = self.decimal.Clamped
3605 Overflow = self.decimal.Overflow
3621 self.assertRaises(Overflow, c2.power, Decimal('3.4e200'), 2)
3634 localcontext = self.decimal.localcontext
3646 localcontext = self.decimal.localcontext
3658 Context = self.decimal.Context
3659 localcontext = self.decimal.localcontext
3660 getcontext = self.decimal.getcontext
3661 setcontext = self.decimal.setcontext
3691 decimal = C variable in CContextWithStatement
3693 decimal = P variable in PyContextWithStatement
3700 Decimal = self.decimal.Decimal
3701 Context = self.decimal.Context
3702 Inexact = self.decimal.Inexact
3703 Rounded = self.decimal.Rounded
3704 Underflow = self.decimal.Underflow
3705 Clamped = self.decimal.Clamped
3706 Subnormal = self.decimal.Subnormal
3709 if self.decimal == C:
3721 (context._apply, [Decimal("100E-425000010")]),
3722 (context.sqrt, [Decimal(2)]),
3723 (context.add, [Decimal("1.23456789"), Decimal("9.87654321")]),
3724 (context.multiply, [Decimal("1.23456789"), Decimal("9.87654321")]),
3725 (context.subtract, [Decimal("1.23456789"), Decimal("9.87654321")]),
3764 Context = self.decimal.Context
3765 Inexact = self.decimal.Inexact
3766 Rounded = self.decimal.Rounded
3803 Decimal = self.decimal.Decimal
3804 FloatOperation = self.decimal.FloatOperation
3805 localcontext = self.decimal.localcontext
3813 self.assertEqual(Decimal(7.5), 7.5)
3822 x = Decimal.from_float(7.5)
3839 self.assertRaises(FloatOperation, Decimal, 7.5)
3848 x = Decimal.from_float(7.5)
3856 Decimal = self.decimal.Decimal
3857 Context = self.decimal.Context
3858 FloatOperation = self.decimal.FloatOperation
3859 localcontext = self.decimal.localcontext
3870 small_d = Decimal('0.25')
3871 big_d = Decimal('3.0')
3875 zero_d = Decimal('0.0')
3876 neg_zero_d = Decimal('-0.0')
3880 inf_d = Decimal('Infinity')
3881 neg_inf_d = Decimal('-Infinity')
3908 assert_attr(Decimal('0.1'), 0.1, '__ne__', c, None)
3913 assert_attr(Decimal('NaN'), float('nan'), '__ne__', c, None)
3917 s = set([100.0, Decimal('100.0')])
3923 self.assertRaises(signal, sorted, [1.0, Decimal('10.0')])
3925 s = sorted([10.0, Decimal('10.0')])
3929 b = 10.0 in [Decimal('10.0'), 1.0]
3933 b = 10.0 in {Decimal('10.0'):'a', 1.0:'b'}
3947 Decimal = self.decimal.Decimal
3948 Context = self.decimal.Context
3949 Inexact = self.decimal.Inexact
3950 FloatOperation= self.decimal.FloatOperation
3963 decimal = C variable in CContextFlags
3965 decimal = P variable in PyContextFlags
3971 BasicContext = self.decimal.BasicContext
3972 ExtendedContext = self.decimal.ExtendedContext
3973 getcontext = self.decimal.getcontext
3974 setcontext = self.decimal.setcontext
3975 InvalidOperation = self.decimal.InvalidOperation
3976 DivisionByZero = self.decimal.DivisionByZero
3977 Overflow = self.decimal.Overflow
3978 Underflow = self.decimal.Underflow
3979 Clamped = self.decimal.Clamped
4007 DefaultContext = self.decimal.DefaultContext
4008 BasicContext = self.decimal.BasicContext
4009 ExtendedContext = self.decimal.ExtendedContext
4010 getcontext = self.decimal.getcontext
4011 setcontext = self.decimal.setcontext
4012 InvalidOperation = self.decimal.InvalidOperation
4013 DivisionByZero = self.decimal.DivisionByZero
4014 Overflow = self.decimal.Overflow
4048 decimal = C variable in CSpecialContexts
4050 decimal = P variable in PySpecialContexts
4055 Context = self.decimal.Context
4056 DefaultContext = self.decimal.DefaultContext
4115 decimal = C variable in CContextInputValidation
4117 decimal = P variable in PyContextInputValidation
4122 decimal = self.decimal
4123 Decimal = decimal.Decimal
4124 Context = decimal.Context
4125 Clamped = decimal.Clamped
4126 DivisionByZero = decimal.DivisionByZero
4127 Inexact = decimal.Inexact
4128 Overflow = decimal.Overflow
4129 Rounded = decimal.Rounded
4130 Subnormal = decimal.Subnormal
4131 Underflow = decimal.Underflow
4132 InvalidOperation = decimal.InvalidOperation
4153 flags = {v:(v in flags) for v in OrderedSignals[decimal] + flags}
4157 traps = {v:(v in traps) for v in OrderedSignals[decimal] + traps}
4170 self.assertRaises(InvalidOperation, c.quantize, Decimal('9e2'), 0)
4176 self.assertEqual(c.plus(Decimal('9.9')), 9)
4182 x = c.add(Decimal('1e-99'), Decimal('2.234e-2000'))
4183 self.assertEqual(x, Decimal('0.0'))
4191 self.assertRaises(Overflow, c.add, Decimal('1e99'), Decimal('2.234e2000'))
4192 if self.decimal == C:
4207 x = c.plus(Decimal('1e99'))
4216 for signal in OrderedSignals[decimal]:
4225 for signal in OrderedSignals[decimal]:
4229 decimal = C variable in CContextSubclassing
4231 decimal = P variable in PyContextSubclassing
4259 x = [s for s in dir(C.Decimal(9)) if '__' in s or not s.startswith('_')]
4260 y = [s for s in dir(C.Decimal(9)) if '__' in s or not s.startswith('_')]
4266 Decimal = self.decimal.Decimal
4268 self.assertEqual(Decimal('1234e9999').adjusted(), 10002)
4270 self.assertEqual(Decimal('nan').adjusted(), 0)
4271 self.assertEqual(Decimal('inf').adjusted(), 0)
4274 Decimal = self.decimal.Decimal
4275 getcontext = self.decimal.getcontext
4277 x = Decimal(9).canonical()
4281 x = c.canonical(Decimal(9))
4285 c = self.decimal.DefaultContext.copy()
4293 for sig in OrderedSignals[self.decimal]:
4304 Decimal = self.decimal.Decimal
4305 localcontext = self.decimal.localcontext
4313 self.assertEqual(abs(Decimal("-10")), 10)
4315 self.assertEqual(Decimal("7") + 1, 8)
4317 self.assertEqual(Decimal("10") / 5, 2)
4319 self.assertEqual(Decimal("10") // 7, 1)
4321 self.assertEqual(Decimal("1.2").fma(Decimal("0.01"), 1), 1)
4322 self.assertIs(Decimal("NaN").fma(7, 1).is_nan(), True)
4324 self.assertEqual(pow(Decimal(10), 2, 7), 2)
4326 self.assertEqual(Decimal("1.01").exp(), 3)
4328 self.assertIs(Decimal("0.01").is_normal(), False)
4330 self.assertIs(Decimal("0.01").is_subnormal(), True)
4332 self.assertEqual(Decimal("20").ln(), 3)
4334 self.assertEqual(Decimal("20").log10(), 1)
4336 self.assertEqual(Decimal("580").logb(), 2)
4338 self.assertEqual(Decimal("10").logical_invert(), 1)
4340 self.assertEqual(-Decimal("-10"), 10)
4342 self.assertEqual(Decimal("2") * 4, 8)
4344 self.assertEqual(Decimal("10").next_minus(), 9)
4346 self.assertEqual(Decimal("10").next_plus(), Decimal('2E+1'))
4348 self.assertEqual(Decimal("-10").normalize(), Decimal('-1E+1'))
4350 self.assertEqual(Decimal("10").number_class(), '+Normal')
4352 self.assertEqual(+Decimal("-1"), -1)
4354 self.assertEqual(Decimal("10") % 7, 3)
4356 self.assertEqual(Decimal("10") - 7, 3)
4358 self.assertEqual(Decimal("1.12345").to_integral_exact(), 1)
4361 self.assertTrue(Decimal("1").is_canonical())
4362 self.assertTrue(Decimal("1").is_finite())
4363 self.assertTrue(Decimal("1").is_finite())
4364 self.assertTrue(Decimal("snan").is_snan())
4365 self.assertTrue(Decimal("-1").is_signed())
4366 self.assertTrue(Decimal("0").is_zero())
4367 self.assertTrue(Decimal("0").is_zero())
4373 y = -Decimal(x)
4381 z = y.copy_sign(Decimal(1))
4385 Decimal = self.decimal.Decimal
4386 localcontext = self.decimal.localcontext
4387 InvalidOperation = self.decimal.InvalidOperation
4388 DivisionByZero = self.decimal.DivisionByZero
4391 q, r = divmod(Decimal("10912837129"), 1001)
4392 self.assertEqual(q, Decimal('10901935'))
4393 self.assertEqual(r, Decimal('194'))
4395 q, r = divmod(Decimal("NaN"), 7)
4399 q, r = divmod(Decimal("NaN"), 7)
4404 q, r = divmod(Decimal("inf"), Decimal("inf"))
4409 q, r = divmod(Decimal("inf"), 101)
4414 q, r = divmod(Decimal(0), 0)
4420 q, r = divmod(Decimal(11), 0)
4426 Decimal = self.decimal.Decimal
4427 localcontext = self.decimal.localcontext
4428 Overflow = self.decimal.Overflow
4429 Rounded = self.decimal.Rounded
4434 self.assertEqual(Decimal("1.0") ** 100, Decimal('1.00'))
4442 self.assertEqual(Decimal(10000) ** Decimal("0.5"), Decimal('inf'))
4446 Decimal = self.decimal.Decimal
4447 localcontext = self.decimal.localcontext
4448 InvalidOperation = self.decimal.InvalidOperation
4455 x = Decimal(99).quantize(Decimal("1e1"))
4459 Decimal = self.decimal.Decimal
4460 getcontext = self.decimal.getcontext
4463 self.assertEqual(Decimal("1").radix(), 10)
4467 Decimal = self.decimal.Decimal
4471 self.assertIs(getattr(Decimal("1"), attr)("xyz"), NotImplemented)
4474 # Python3 behavior: round() returns Decimal
4475 Decimal = self.decimal.Decimal
4476 localcontext = self.decimal.localcontext
4481 self.assertEqual(str(Decimal("9.99").__round__()), "10")
4482 self.assertEqual(str(Decimal("9.99e-5").__round__()), "0")
4483 self.assertEqual(str(Decimal("1.23456789").__round__(5)), "1.23457")
4484 self.assertEqual(str(Decimal("1.2345").__round__(10)), "1.2345000000")
4485 self.assertEqual(str(Decimal("1.2345").__round__(-10)), "0E+10")
4487 self.assertRaises(TypeError, Decimal("1.23").__round__, "5")
4488 self.assertRaises(TypeError, Decimal("1.23").__round__, 5, 8)
4491 c = self.decimal.Context()
4495 Decimal = self.decimal.Decimal
4496 localcontext = self.decimal.localcontext
4500 x = Decimal(1221**1271) / 10**3923
4505 Context = self.decimal.Context
4521 decimal = C variable in CCoverage
4523 decimal = P variable in PyCoverage
4526 """Extra functionality in decimal.py"""
4529 # triples giving a format, a Decimal, and the expected result
4530 Decimal = P.Decimal
4547 self.assertEqual(format(Decimal(d), fmt), result)
4550 """White box testing for decimal.py"""
4554 Decimal = P.Decimal
4559 x = Decimal(2**16) ** Decimal("-0.5")
4560 self.assertEqual(x, Decimal('0.00390625'))
4562 x = Decimal(2**16) ** Decimal("-0.6")
4563 self.assertEqual(x, Decimal('0.0012885819'))
4565 x = Decimal("256e7") ** Decimal("-0.5")
4567 x = Decimal(152587890625) ** Decimal('-0.0625')
4568 self.assertEqual(x, Decimal("0.2"))
4570 x = Decimal("152587890625e7") ** Decimal('-0.0625')
4572 x = Decimal(5**2659) ** Decimal('-0.0625')
4575 x = Decimal("152587890625") ** Decimal('-0.5')
4577 x = Decimal(2**578) ** Decimal("-0.5")
4581 Decimal = P.Decimal
4589 d1 = Decimal('-25e55')
4590 b1 = Decimal('-25e55')
4591 d2 = Decimal('33e+33')
4592 b2 = Decimal('33e+33')
4609 Decimal(d1)
4659 Decimal = P.Decimal
4661 d = Decimal(45)
4662 e = Decimal(d)
4668 Decimal = P.Decimal
4672 x = Decimal("NaN")._rescale(3, ROUND_UP)
4677 Decimal = P.Decimal
4679 self.assertRaises(ValueError, Decimal("3.1234")._round, 0, ROUND_UP)
4686 # issue 8786: Add support for IEEE 754 contexts to decimal module.
4772 Decimal = C.Decimal
4783 y = Decimal(a) ** Decimal(b)
4787 self.assertRaises(TypeError, C.Decimal, 9, "xyz")
4791 Decimal = C.Decimal
4797 self.assertRaises(InvalidOperation, Decimal,
5033 Decimal = C.Decimal
5042 self.assertRaises(InvalidOperation, Decimal("1.23").__round__,
5044 self.assertRaises(InvalidOperation, Decimal("1.23").__round__,
5046 self.assertRaises(InvalidOperation, Decimal("1").__round__,
5048 self.assertRaises(C.InvalidOperation, Decimal("1").__round__,
5050 self.assertRaises(OverflowError, Decimal("1.23").__round__,
5052 self.assertRaises(OverflowError, Decimal("1.23").__round__,
5057 Decimal = C.Decimal
5060 self.assertRaises(TypeError, Decimal(1).__format__, "=10.10", [], 9)
5061 self.assertRaises(TypeError, Decimal(1).__format__, "=10.10", 9)
5062 self.assertRaises(TypeError, Decimal(1).__format__, [])
5064 self.assertRaises(ValueError, Decimal(1).__format__, "<>=10.10")
5066 self.assertRaises(ValueError, Decimal("1.23456789").__format__,
5070 Decimal = C.Decimal
5074 x = Decimal(10)
5091 x = Decimal("99999999999999999999999999.9").to_integral_value(ROUND_UP)
5092 self.assertEqual(x, Decimal('100000000000000000000000000'))
5094 x = Decimal("99999999999999999999999999.9").to_integral_exact(ROUND_UP)
5095 self.assertEqual(x, Decimal('100000000000000000000000000'))
5098 self.assertRaises(Inexact, Decimal("999.9").to_integral_exact, ROUND_UP)
5102 Decimal = C.Decimal
5108 self.assertEqual(Decimal('9.99e10').to_eng_string(), '99.9E+9')
5110 self.assertRaises(TypeError, pow, Decimal(1), 2, "3")
5111 self.assertRaises(TypeError, Decimal(9).number_class, "x", "y")
5112 self.assertRaises(TypeError, Decimal(9).same_quantum, 3, "x", "y")
5116 Decimal("1.23456789").quantize, Decimal('1e-100000'), []
5120 Decimal("1.23456789").quantize, Decimal('1e-100000'), getcontext()
5124 Decimal("1.23456789").quantize, Decimal('1e-100000'), 10
5128 Decimal("1.23456789").quantize, Decimal('1e-100000'), ROUND_UP, 1000
5135 self.assertRaises(TypeError, c.copy_sign, Decimal(1), "x", "y")
5141 self.assertEqual(str(c.canonical(Decimal(200))), '200')
5145 self.assertRaises(DivisionByZero, Decimal(9).__divmod__, 0)
5151 self.assertRaises(InvalidOperation, Decimal(9).__divmod__, 0)
5157 self.assertRaises(InvalidOperation, pow, Decimal(1000), 1, 501)
5160 Decimal = C.Decimal
5163 x = Decimal("10001111111")
5350 Decimal = C.Decimal
5361 return Decimal(x).__format__(fmt, override)
5387 Decimal = C.Decimal
5397 self.assertRaises(InvalidOperation, Decimal, x)
5400 self.assertRaises(InvalidOperation, Decimal, x)
5404 self.assertRaises(InvalidOperation, Decimal, x)
5408 self.assertRaises(InvalidOperation, Decimal, x)
5411 Decimal = C.Decimal
5426 self.assertRaises(InvalidOperation, Decimal, x)
5430 self.assertRaises(InvalidOperation, Decimal, x)
5435 self.assertRaises(InvalidOperation, Decimal, x)
5439 self.assertRaises(InvalidOperation, Decimal, x)
5444 self.assertRaises(OverflowError, Decimal, x)
5448 self.assertRaises(OverflowError, Decimal, x)
5452 self.assertEqual(str(Decimal(x)), '-sNaN')
5454 self.assertEqual(str(Decimal(x)), '-sNaN')
5456 self.assertEqual(str(Decimal(x)), '-sNaN1')
5459 Decimal = C.Decimal
5462 self.assertGreater(Decimal(0).__sizeof__(), 0)
5464 x = Decimal(10**(19*24)).__sizeof__()
5465 y = Decimal(10**(19*25)).__sizeof__()
5468 x = Decimal(10**(9*24)).__sizeof__()
5469 y = Decimal(10**(9*25)).__sizeof__()
5473 Decimal = C.Decimal
5497 self.assertEqual(Decimal.from_float(cls(101.1)),
5498 Decimal.from_float(101.1))
5519 Decimal = C.Decimal
5527 self.assertEqual(Decimal(0).exp(), 1)
5528 self.assertEqual(Decimal(1).ln(), 0)
5529 self.assertEqual(Decimal(1).log10(), 0)
5530 self.assertEqual(Decimal(10**2).log10(), 2)
5531 self.assertEqual(Decimal(10**223).log10(), 223)
5532 self.assertEqual(Decimal(10**19).logb(), 19)
5533 self.assertEqual(Decimal(4).sqrt(), 2)
5534 self.assertEqual(Decimal("40E9").sqrt(), Decimal('2.0E+5'))
5535 self.assertEqual(divmod(Decimal(10), 3), (3, 1))
5536 self.assertEqual(Decimal(10) // 3, 3)
5537 self.assertEqual(Decimal(4) / 2, 2)
5538 self.assertEqual(Decimal(400) ** -1, Decimal('0.0025'))
5552 if (attr == 'Decimal' or attr == 'Context' or
5580 pdict = {C: {'other': C.Decimal(1),
5581 'third': C.Decimal(1),
5582 'x': C.Decimal(1),
5583 'y': C.Decimal(1),
5584 'z': C.Decimal(1),
5585 'a': C.Decimal(1),
5586 'b': C.Decimal(1),
5587 'c': C.Decimal(1),
5588 'exp': C.Decimal(1),
5589 'modulo': C.Decimal(1),
5594 P: {'other': P.Decimal(1),
5595 'third': P.Decimal(1),
5596 'a': P.Decimal(1),
5597 'b': P.Decimal(1),
5598 'c': P.Decimal(1),
5599 'exp': P.Decimal(1),
5600 'modulo': P.Decimal(1),
5654 if ty == 'Decimal':
5674 doit('Decimal')
5709 Runs all arithmetic tests if arith is True or if the "decimal" resource
5716 TEST_ALL = arith if arith is not None else is_resource_enabled('decimal')
5743 savedecimal = sys.modules['decimal']
5745 sys.modules['decimal'] = C
5747 sys.modules['decimal'] = P
5749 sys.modules['decimal'] = savedecimal
5756 if not orig_sys_decimal is sys.modules['decimal']:
5758 "sys.modules['decimal'].")