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
53 C = import_fresh_module('decimal', fresh=['_decimal'])
54 P = import_fresh_module('decimal', blocked=['_decimal'])
55 import decimal as orig_sys_decimal
57 # fractions module must import the correct decimal module.
59 sys.modules['decimal'] = P
61 sys.modules['decimal'] = C
63 sys.modules['decimal'] = orig_sys_decimal
137 """Class which tests the Decimal class against the IBM test cases."""
140 self.context = self.decimal.Context()
141 self.readcontext = self.decimal.Context()
156 # Decimal behaves differently from decNumber for these testcases so these
182 if self.decimal == C:
202 # Name adapter to be able to change the Decimal and Context
253 self.ErrorNames = {'clamped' : self.decimal.Clamped,
254 'conversion_syntax' : self.decimal.InvalidOperation,
255 'division_by_zero' : self.decimal.DivisionByZero,
256 'division_impossible' : self.decimal.InvalidOperation,
257 'division_undefined' : self.decimal.InvalidOperation,
258 'inexact' : self.decimal.Inexact,
259 'invalid_context' : self.decimal.InvalidOperation,
260 'invalid_operation' : self.decimal.InvalidOperation,
261 'overflow' : self.decimal.Overflow,
262 'rounded' : self.decimal.Rounded,
263 'subnormal' : self.decimal.Subnormal,
264 'underflow' : self.decimal.Underflow}
267 # Decimal instance.
286 if self.decimal == C and self.decimal.MAX_EMAX == 425000000:
292 return self.decimal.Decimal(v, context)
304 except self.decimal.DecimalException as exception:
359 raise self.decimal.InvalidOperation
378 for exception in Signals[self.decimal]:
400 except Signals[self.decimal] as e:
420 except Signals[self.decimal] as e:
428 ordered_errors = [e for e in OrderedSignals[self.decimal] if e in theirexceptions]
435 except Signals[self.decimal] as e:
451 except Signals[self.decimal] as error:
469 return [e for e in Signals[self.decimal] if self.context.flags[e]]
472 if self.decimal == C and self.decimal.MAX_PREC == 425000000:
479 if self.decimal == C and self.decimal.MAX_PREC == 425000000:
484 if self.decimal == C and self.decimal.MAX_PREC == 425000000:
492 decimal = C variable in CIBMTestCases
494 decimal = P variable in PyIBMTestCases
496 # The following classes test the behaviour of Decimal according to PEP 327
499 '''Unit tests for Explicit Construction cases of Decimal.'''
502 Decimal = self.decimal.Decimal
503 self.assertEqual(Decimal(), Decimal("0"))
506 Decimal = self.decimal.Decimal
507 self.assertRaises(TypeError, Decimal, None)
510 Decimal = self.decimal.Decimal
513 d = Decimal(45)
517 d = Decimal(500000123)
521 d = Decimal(-45)
525 d = Decimal(0)
533 d = Decimal(i)
537 Decimal = self.decimal.Decimal
538 InvalidOperation = self.decimal.InvalidOperation
539 localcontext = self.decimal.localcontext
542 self.assertEqual(str(Decimal('')), 'NaN')
545 self.assertEqual(str(Decimal('45')), '45')
548 self.assertEqual(str(Decimal('45.34')), '45.34')
551 self.assertEqual(str(Decimal('45e2')), '4.5E+3')
554 self.assertEqual(str(Decimal('ugly')), 'NaN')
557 self.assertEqual(str(Decimal('1.3E4 \n')), '1.3E+4')
558 self.assertEqual(str(Decimal(' -7.89')), '-7.89')
559 self.assertEqual(str(Decimal(" 3.45679 ")), '3.45679')
562 self.assertEqual(str(Decimal('1_3.3e4_0')), '1.33E+41')
563 self.assertEqual(str(Decimal('1_0_0_0')), '1000')
568 self.assertEqual(str(Decimal(lead + '9.311E+28' + trail)),
574 self.assertRaises(InvalidOperation, Decimal, "xyz")
576 self.assertRaises(TypeError, Decimal, "1234", "x", "y")
579 self.assertRaises(InvalidOperation, Decimal, "1\u00a02\u00a03")
580 self.assertRaises(InvalidOperation, Decimal, "\u00a01\u00a02\u00a0")
583 self.assertRaises(InvalidOperation, Decimal, "\u00a0")
584 self.assertRaises(InvalidOperation, Decimal, "\u00a0\u00a0")
587 self.assertRaises(InvalidOperation, Decimal, "12\u00003")
590 self.assertRaises(InvalidOperation, Decimal, "1_2_\u00003")
597 Decimal = self.decimal.Decimal
598 context = self.decimal.Context()
601 self.assertEqual(str(Decimal(s)), '9.999999')
605 Decimal = self.decimal.Decimal
608 d = Decimal( (0, (0,), 0) )
612 d = Decimal( (1, (4, 5), 0) )
616 d = Decimal( (0, (4, 5, 3, 4), -2) )
620 d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
624 d = Decimal( (0, (), "F") )
628 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1)) )
631 self.assertRaises(ValueError, Decimal, (8, (4, 3, 4, 9, 1), 2) )
632 self.assertRaises(ValueError, Decimal, (0., (4, 3, 4, 9, 1), 2) )
633 self.assertRaises(ValueError, Decimal, (Decimal(1), (4, 3, 4, 9, 1), 2))
636 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), 'wrong!') )
637 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), 0.) )
638 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 9, 1), '1') )
641 self.assertRaises(ValueError, Decimal, (1, "xyz", 2) )
642 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, None, 1), 2) )
643 self.assertRaises(ValueError, Decimal, (1, (4, -3, 4, 9, 1), 2) )
644 self.assertRaises(ValueError, Decimal, (1, (4, 10, 4, 9, 1), 2) )
645 self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 'a', 1), 2) )
648 Decimal = self.decimal.Decimal
650 d = Decimal([0, [0], 0])
653 d = Decimal([1, [4, 3, 4, 9, 1, 3, 5, 3, 4], -25])
656 d = Decimal([1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25])
659 d = Decimal((1, [4, 3, 4, 9, 1, 3, 5, 3, 4], -25))
663 Decimal = self.decimal.Decimal
665 self.assertIs(bool(Decimal(0)), False)
666 self.assertIs(bool(Decimal(1)), True)
667 self.assertEqual(Decimal(False), Decimal(0))
668 self.assertEqual(Decimal(True), Decimal(1))
671 Decimal = self.decimal.Decimal
674 d = Decimal(45)
675 e = Decimal(d)
679 d = Decimal(500000123)
680 e = Decimal(d)
684 d = Decimal(-45)
685 e = Decimal(d)
689 d = Decimal(0)
690 e = Decimal(d)
696 Decimal = self.decimal.Decimal
698 r = Decimal(0.1)
699 self.assertEqual(type(r), Decimal)
702 self.assertTrue(Decimal(float('nan')).is_qnan())
703 self.assertTrue(Decimal(float('inf')).is_infinite())
704 self.assertTrue(Decimal(float('-inf')).is_infinite())
705 self.assertEqual(str(Decimal(float('nan'))),
706 str(Decimal('NaN')))
707 self.assertEqual(str(Decimal(float('inf'))),
708 str(Decimal('Infinity')))
709 self.assertEqual(str(Decimal(float('-inf'))),
710 str(Decimal('-Infinity')))
711 self.assertEqual(str(Decimal(float('-0.0'))),
712 str(Decimal('-0')))
715 self.assertEqual(x, float(Decimal(x))) # roundtrip
718 Decimal = self.decimal.Decimal
719 InvalidOperation = self.decimal.InvalidOperation
720 Rounded = self.decimal.Rounded
722 nc = copy.copy(self.decimal.getcontext())
726 d = Decimal()
736 self.assertIsInstance(d, Decimal)
741 d = Decimal('456789')
751 d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
756 # from Decimal
757 prevdec = Decimal(500000123)
758 d = Decimal(prevdec)
770 self.assertTrue(isinstance(d, Decimal))
796 Decimal('NaN12345'))
803 self.assertEqual(str(nc.create_decimal(Decimal('NaN12345'))), 'NaN')
808 Decimal = self.decimal.Decimal
810 nc = self.decimal.Context()
812 self.assertEqual(type(r), Decimal)
831 Decimal = self.decimal.Decimal
839 self.assertEqual(str(Decimal(input)), expected)
842 decimal = C variable in CExplicitConstructionTest
844 decimal = P variable in PyExplicitConstructionTest
847 '''Unit tests for Implicit Construction cases of Decimal.'''
850 Decimal = self.decimal.Decimal
851 self.assertRaises(TypeError, eval, 'Decimal(5) + None', locals())
854 Decimal = self.decimal.Decimal
857 self.assertEqual(str(Decimal(5) + 45), '50')
859 self.assertEqual(Decimal(5) + 123456789000, Decimal(123456789000))
862 Decimal = self.decimal.Decimal
863 self.assertRaises(TypeError, eval, 'Decimal(5) + "3"', locals())
866 Decimal = self.decimal.Decimal
867 self.assertRaises(TypeError, eval, 'Decimal(5) + 2.2', locals())
870 Decimal = self.decimal.Decimal
871 self.assertEqual(Decimal(5) + Decimal(45), Decimal(50))
874 Decimal = self.decimal.Decimal
895 self.assertEqual(divmod(E(), Decimal(10)), 'divmod 10')
896 self.assertEqual(divmod(Decimal(10), E()), '10 rdivmod')
897 self.assertEqual(eval('Decimal(10) < E()'), 'gt 10')
898 self.assertEqual(eval('Decimal(10) > E()'), 'lt 10')
899 self.assertEqual(eval('Decimal(10) <= E()'), 'ge 10')
900 self.assertEqual(eval('Decimal(10) >= E()'), 'le 10')
901 self.assertEqual(eval('Decimal(10) == E()'), 'eq 10')
902 self.assertEqual(eval('Decimal(10) != E()'), 'ne 10')
918 self.assertEqual(eval('E()' + sym + 'Decimal(10)'),
920 self.assertEqual(eval('Decimal(10)' + sym + 'E()'),
924 decimal = C variable in CImplicitConstructionTest
926 decimal = P variable in PyImplicitConstructionTest
931 Decimal = self.decimal.Decimal
933 # triples giving a format, a Decimal, and the expected result
969 ('.0f', '0', '0'), # no decimal point
1135 self.assertEqual(format(Decimal(d), fmt), result)
1138 self.assertRaises(TypeError, Decimal(1).__format__, b'-020')
1141 with self.decimal.localcontext() as ctx:
1143 self.assertEqual(format(self.decimal.Decimal('-0.001'), 'z.2f'),
1147 self.assertRaises(ValueError, format, self.decimal.Decimal('1.23'), 'fz')
1150 Decimal = self.decimal.Decimal
1158 return ''.join([chr(x) for x in lst]) if self.decimal == C else lst
1161 if self.decimal == C:
1162 return Decimal(x).__format__(fmt, override)
1164 return Decimal(x).__format__(fmt, _localeconv=override)
1197 self.assertEqual(get_fmt(Decimal('12.7'), en_US), '12.7')
1198 self.assertEqual(get_fmt(Decimal('12.7'), fr_FR), '12,7')
1199 self.assertEqual(get_fmt(Decimal('12.7'), ru_RU), '12,7')
1200 self.assertEqual(get_fmt(Decimal('12.7'), crazy), '1-2&7')
1234 # wide char separator and decimal point
1235 self.assertEqual(get_fmt(Decimal('-1.5'), dotsep_wide, '020n'),
1240 # locale with wide char separator and decimal point
1241 Decimal = self.decimal.Decimal
1246 self.skipTest('inappropriate decimal point separator '
1252 self.assertEqual(format(Decimal('100000000.123'), 'n'),
1256 class A(self.decimal.Decimal):
1260 self.assertEqual(self.decimal.Decimal, a.a_type)
1263 self.assertEqual(self.decimal.Decimal, a.a_type)
1266 decimal = C variable in CFormatTest
1268 decimal = P variable in PyFormatTest
1274 Decimal = self.decimal.Decimal
1276 d1 = Decimal('-11.1')
1277 d2 = Decimal('22.2')
1280 self.assertEqual(d1+d2, Decimal('11.1'))
1281 self.assertEqual(d2+d1, Decimal('11.1'))
1285 self.assertEqual(c, Decimal('-6.1'))
1290 self.assertEqual(c, Decimal('-6.1'))
1293 #inline with decimal
1295 self.assertEqual(d1, Decimal('11.1'))
1299 self.assertEqual(d1, Decimal('16.1'))
1302 Decimal = self.decimal.Decimal
1304 d1 = Decimal('-11.1')
1305 d2 = Decimal('22.2')
1308 self.assertEqual(d1-d2, Decimal('-33.3'))
1309 self.assertEqual(d2-d1, Decimal('33.3'))
1313 self.assertEqual(c, Decimal('-16.1'))
1318 self.assertEqual(c, Decimal('16.1'))
1321 #inline with decimal
1323 self.assertEqual(d1, Decimal('-33.3'))
1327 self.assertEqual(d1, Decimal('-38.3'))
1330 Decimal = self.decimal.Decimal
1332 d1 = Decimal('-5')
1333 d2 = Decimal('3')
1336 self.assertEqual(d1*d2, Decimal('-15'))
1337 self.assertEqual(d2*d1, Decimal('-15'))
1341 self.assertEqual(c, Decimal('-25'))
1346 self.assertEqual(c, Decimal('-25'))
1349 #inline with decimal
1351 self.assertEqual(d1, Decimal('-15'))
1355 self.assertEqual(d1, Decimal('-75'))
1358 Decimal = self.decimal.Decimal
1360 d1 = Decimal('-5')
1361 d2 = Decimal('2')
1364 self.assertEqual(d1/d2, Decimal('-2.5'))
1365 self.assertEqual(d2/d1, Decimal('-0.4'))
1369 self.assertEqual(c, Decimal('-1.25'))
1374 self.assertEqual(c, Decimal('-0.8'))
1377 #inline with decimal
1379 self.assertEqual(d1, Decimal('-2.5'))
1383 self.assertEqual(d1, Decimal('-0.625'))
1386 Decimal = self.decimal.Decimal
1388 d1 = Decimal('5')
1389 d2 = Decimal('2')
1392 self.assertEqual(d1//d2, Decimal('2'))
1393 self.assertEqual(d2//d1, Decimal('0'))
1397 self.assertEqual(c, Decimal('1'))
1402 self.assertEqual(c, Decimal('1'))
1405 #inline with decimal
1407 self.assertEqual(d1, Decimal('2'))
1411 self.assertEqual(d1, Decimal('1'))
1414 Decimal = self.decimal.Decimal
1416 d1 = Decimal('5')
1417 d2 = Decimal('2')
1420 self.assertEqual(d1**d2, Decimal('25'))
1421 self.assertEqual(d2**d1, Decimal('32'))
1425 self.assertEqual(c, Decimal('625'))
1430 self.assertEqual(c, Decimal('16807'))
1433 #inline with decimal
1435 self.assertEqual(d1, Decimal('25'))
1439 self.assertEqual(d1, Decimal('390625'))
1442 Decimal = self.decimal.Decimal
1444 d1 = Decimal('5')
1445 d2 = Decimal('2')
1448 self.assertEqual(d1%d2, Decimal('1'))
1449 self.assertEqual(d2%d1, Decimal('2'))
1453 self.assertEqual(c, Decimal('1'))
1458 self.assertEqual(c, Decimal('2'))
1461 #inline with decimal
1463 self.assertEqual(d1, Decimal('1'))
1467 self.assertEqual(d1, Decimal('1'))
1470 Decimal = self.decimal.Decimal
1472 d1 = Decimal('5')
1473 d2 = Decimal('2')
1477 self.assertEqual(p, Decimal('2'))
1478 self.assertEqual(q, Decimal('1'))
1484 self.assertEqual(p, Decimal('1'))
1485 self.assertEqual(q, Decimal('1'))
1491 self.assertEqual(p, Decimal('1'))
1492 self.assertEqual(q, Decimal('2'))
1497 Decimal = self.decimal.Decimal
1499 self.assertEqual(+Decimal(45), Decimal(+45)) # +
1500 self.assertEqual(-Decimal(45), Decimal(-45)) # -
1501 self.assertEqual(abs(Decimal(45)), abs(Decimal(-45))) # abs
1511 Decimal = self.decimal.Decimal
1512 InvalidOperation = self.decimal.InvalidOperation
1513 localcontext = self.decimal.localcontext
1515 n = Decimal('NaN')
1516 s = Decimal('sNaN')
1517 i = Decimal('Inf')
1518 f = Decimal('2')
1559 Decimal = self.decimal.Decimal
1561 d = Decimal(1).copy_sign(Decimal(-2))
1562 self.assertEqual(Decimal(1).copy_sign(-2), d)
1563 self.assertRaises(TypeError, Decimal(1).copy_sign, '-2')
1566 decimal = C variable in CArithmeticOperatorsTest
1568 decimal = P variable in PyArithmeticOperatorsTest
1573 Decimal = cls.decimal.Decimal
1574 InvalidOperation = cls.decimal.InvalidOperation
1575 DivisionByZero = cls.decimal.DivisionByZero
1576 Overflow = cls.decimal.Overflow
1577 Underflow = cls.decimal.Underflow
1578 Inexact = cls.decimal.Inexact
1579 getcontext = cls.decimal.getcontext
1580 localcontext = cls.decimal.localcontext
1582 d1 = Decimal(1)
1583 d3 = Decimal(3)
1597 cls.assertRaises(InvalidOperation, c3.compare, d1, Decimal('sNaN'))
1603 cls.assertEqual(test1, Decimal('0.333333333333333333333333'))
1604 cls.assertEqual(test2, Decimal('0.333333333333333333333333'))
1612 Decimal = cls.decimal.Decimal
1613 InvalidOperation = cls.decimal.InvalidOperation
1614 DivisionByZero = cls.decimal.DivisionByZero
1615 Overflow = cls.decimal.Overflow
1616 Underflow = cls.decimal.Underflow
1617 Inexact = cls.decimal.Inexact
1618 getcontext = cls.decimal.getcontext
1619 localcontext = cls.decimal.localcontext
1621 d1 = Decimal(1)
1622 d3 = Decimal(3)
1631 cls.assertRaises(Overflow, c2.multiply, Decimal('1e425000000'), 999)
1637 cls.assertRaises(Underflow, c3.divide, Decimal('1e-425000000'), 999)
1647 cls.assertEqual(test1, Decimal('0.333333333333333333333333'))
1648 cls.assertEqual(test2, Decimal('0.333333333333333333'))
1658 '''Unit tests for thread local contexts in Decimal.'''
1664 DefaultContext = self.decimal.DefaultContext
1666 if self.decimal == C and not self.decimal.HAVE_THREADS:
1691 for sig in Signals[self.decimal]:
1703 decimal = C variable in CThreadingTest
1706 decimal = P variable in PyThreadingTest
1709 '''Unit tests for Usability cases of Decimal.'''
1713 Decimal = self.decimal.Decimal
1715 da = Decimal('23.42')
1716 db = Decimal('23.42')
1717 dc = Decimal('45')
1729 #a Decimal and an int
1734 #a Decimal and uncomparable
1741 a = list(map(Decimal, range(100)))
1748 Decimal = self.decimal.Decimal
1750 da = Decimal('0.25')
1751 db = Decimal('3.0')
1764 self.assertNotEqual(0.1, Decimal('0.1'))
1767 Decimal = self.decimal.Decimal
1769 da = Decimal('0.25')
1770 db = Decimal('3.0')
1787 D = self.decimal.Decimal
1788 F = fractions[self.decimal].Fraction
1789 Context = self.decimal.Context
1790 localcontext = self.decimal.localcontext
1791 InvalidOperation = self.decimal.InvalidOperation
1829 Decimal = self.decimal.Decimal
1831 d = Decimal('43.24')
1839 Decimal = self.decimal.Decimal
1840 localcontext = self.decimal.localcontext
1849 hashit(Decimal(23))
1850 hashit(Decimal('Infinity'))
1851 hashit(Decimal('-Infinity'))
1852 hashit(Decimal('nan123'))
1853 hashit(Decimal('-NaN'))
1855 test_values = [Decimal(sign*(2**m + n))
1861 Decimal("-1"), # ==> -2
1862 Decimal("-0"), # zeros
1863 Decimal("0.00"),
1864 Decimal("-0.000"),
1865 Decimal("0E10"),
1866 Decimal("-0E12"),
1867 Decimal("10.0"), # negative exponent
1868 Decimal("-23.00000"),
1869 Decimal("1230E100"), # positive exponent
1870 Decimal("-4.5678E50"),
1873 Decimal(2**64 + 2**32 - 1),
1876 Decimal("1.634E100"),
1877 Decimal("90.697E100"),
1878 Decimal("188.83E100"),
1879 Decimal("1652.9E100"),
1880 Decimal("56531E100"),
1887 # check that the hashes of a Decimal float match when they
1893 d = Decimal(s)
1899 x = Decimal("123456789.1")
1913 self.assertEqual(hashit(Decimal(x)), hashit(x))
1916 Decimal = self.decimal.Decimal
1917 self.assertRaises(TypeError, hash, Decimal('sNaN'))
1918 value = Decimal('NaN')
1923 class D(Decimal, H):
1929 Decimal = self.decimal.Decimal
1931 d1 = Decimal('15.32')
1932 d2 = Decimal('28.5')
1942 #between Decimal and int
1949 Decimal = self.decimal.Decimal
1952 self.assertFalse(Decimal(0))
1954 self.assertTrue(Decimal('0.372'))
1958 Decimal = self.decimal.Decimal
1960 d = Decimal('15.32')
1962 self.assertEqual(repr(d), "Decimal('15.32')") # repr
1966 Decimal = self.decimal.Decimal
1968 d1 = Decimal('66')
1969 d2 = Decimal('15.32')
1992 self.assertEqual(math.floor(Decimal(d)), i)
1993 self.assertRaises(ValueError, math.floor, Decimal('-NaN'))
1994 self.assertRaises(ValueError, math.floor, Decimal('sNaN'))
1995 self.assertRaises(ValueError, math.floor, Decimal('NaN123'))
1996 self.assertRaises(OverflowError, math.floor, Decimal('Inf'))
1997 self.assertRaises(OverflowError, math.floor, Decimal('-Inf'))
2012 self.assertEqual(math.ceil(Decimal(d)), i)
2013 self.assertRaises(ValueError, math.ceil, Decimal('-NaN'))
2014 self.assertRaises(ValueError, math.ceil, Decimal('sNaN'))
2015 self.assertRaises(ValueError, math.ceil, Decimal('NaN123'))
2016 self.assertRaises(OverflowError, math.ceil, Decimal('Inf'))
2017 self.assertRaises(OverflowError, math.ceil, Decimal('-Inf'))
2039 self.assertEqual(round(Decimal(d)), i)
2040 self.assertRaises(ValueError, round, Decimal('-NaN'))
2041 self.assertRaises(ValueError, round, Decimal('sNaN'))
2042 self.assertRaises(ValueError, round, Decimal('NaN123'))
2043 self.assertRaises(OverflowError, round, Decimal('Inf'))
2044 self.assertRaises(OverflowError, round, Decimal('-Inf'))
2065 self.assertEqual(str(round(Decimal(d), n)), r)
2068 # Test conversions of decimal NANs to float.
2070 Decimal = self.decimal.Decimal
2072 f = float(Decimal(s))
2078 Decimal = self.decimal.Decimal
2080 d = Decimal(s)
2084 Decimal = self.decimal.Decimal
2087 d = Decimal( (0, (0,), 0) )
2091 d = Decimal( (1, (4, 5), 0) )
2095 d = Decimal( (0, (4, 5, 3, 4), -2) )
2099 d = Decimal( (1, (4, 3, 4, 9, 1, 3, 5, 3, 4), -25) )
2103 Decimal = self.decimal.Decimal
2106 d = Decimal(0)
2110 d = Decimal(-45)
2114 d = Decimal("-4.34913534E-17")
2117 # The '0' coefficient is implementation specific to decimal.py.
2119 d = Decimal("Infinity")
2123 d = Decimal( (0, (0, 0, 4, 0, 5, 3, 4), -2) )
2125 d = Decimal( (1, (0, 0, 0), 37) )
2127 d = Decimal( (1, (), 37) )
2131 d = Decimal( (0, (0, 0, 4, 0, 5, 3, 4), 'n') )
2133 d = Decimal( (1, (0, 0, 0), 'N') )
2135 d = Decimal( (1, (), 'n') )
2138 # For infinities, decimal.py has always silently accepted any
2140 d = Decimal( (0, (0,), 'F') )
2142 d = Decimal( (0, (4, 5, 3, 4), 'F') )
2144 d = Decimal( (1, (0, 2, 7, 1), 'F') )
2148 Decimal = self.decimal.Decimal
2152 Decimal.as_integer_ratio, Decimal('inf'))
2154 Decimal.as_integer_ratio, Decimal('-inf'))
2156 Decimal.as_integer_ratio, Decimal('-nan'))
2158 Decimal.as_integer_ratio, Decimal('snan123'))
2163 d = Decimal('%s%dE%d' % (sign, coeff, exp))
2178 self.assertEqual(Decimal(p) / Decimal(q), d)
2181 # Different behaviours when subclassing Decimal
2182 Decimal = self.decimal.Decimal
2184 class MyDecimal(Decimal):
2190 self.assertIs(type(d), Decimal)
2193 self.assertIs(type(d), Decimal)
2203 # Decimal(Decimal)
2204 d = Decimal('1.0')
2205 x = Decimal(d)
2206 self.assertIs(type(x), Decimal)
2209 # MyDecimal(Decimal)
2215 # Decimal(MyDecimal)
2216 x = Decimal(m)
2217 self.assertIs(type(x), Decimal)
2228 Decimal = self.decimal.Decimal
2229 getcontext = self.decimal.getcontext
2233 self.assertEqual(str(Decimal(0).sqrt()),
2234 str(c.sqrt(Decimal(0))))
2237 Decimal = self.decimal.Decimal
2238 Context = self.decimal.Context
2239 localcontext = self.decimal.localcontext
2240 InvalidOperation = self.decimal.InvalidOperation
2241 DivisionByZero = self.decimal.DivisionByZero
2242 Overflow = self.decimal.Overflow
2243 Underflow = self.decimal.Underflow
2244 Subnormal = self.decimal.Subnormal
2245 Inexact = self.decimal.Inexact
2246 Rounded = self.decimal.Rounded
2247 Clamped = self.decimal.Clamped
2254 x = Decimal("111")
2255 y = Decimal("1e9999")
2256 z = Decimal("1e-9999")
2275 self.assertRaises(InvalidOperation, Decimal(-1).ln, context=None)
2283 self.assertRaises(InvalidOperation, Decimal(-1).log10, context=None)
2288 self.assertRaises(DivisionByZero, Decimal(0).logb, context=None)
2298 self.assertRaises(InvalidOperation, Decimal('sNaN').next_minus, context=None)
2303 self.assertRaises(InvalidOperation, Decimal('sNaN').next_plus, context=None)
2331 ans = str(x.compare(Decimal('Nan891287828'), context=None))
2333 self.assertRaises(InvalidOperation, x.compare, Decimal('sNaN'), context=None)
2339 self.assertRaises(InvalidOperation, x.compare_signal, Decimal('NaN'), context=None)
2363 self.assertRaises(InvalidOperation, x.max, Decimal('sNaN'), context=None)
2369 self.assertRaises(InvalidOperation, x.max_mag, Decimal('sNaN'), context=None)
2375 self.assertRaises(InvalidOperation, x.min, Decimal('sNaN'), context=None)
2381 self.assertRaises(InvalidOperation, x.min_mag, Decimal('sNaN'), context=None)
2413 self.assertRaises(Overflow, x.fma, Decimal('1e9999'), 3, context=None)
2419 ans = str(Decimal('1.5').to_integral(rounding=None, context=None))
2422 ans = str(Decimal('1.5').to_integral(rounding=None, context=None))
2424 ans = str(Decimal('1.5').to_integral(rounding=ROUND_UP, context=None))
2427 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral, context=None)
2431 ans = str(Decimal('1.5').to_integral_value(rounding=None, context=None))
2434 ans = str(Decimal('1.5').to_integral_value(rounding=None, context=None))
2436 ans = str(Decimal('1.5').to_integral_value(rounding=ROUND_UP, context=None))
2439 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral_value, context=None)
2443 ans = str(Decimal('1.5').to_integral_exact(rounding=None, context=None))
2446 ans = str(Decimal('1.5').to_integral_exact(rounding=None, context=None))
2448 ans = str(Decimal('1.5').to_integral_exact(rounding=ROUND_UP, context=None))
2451 self.assertRaises(InvalidOperation, Decimal('sNaN').to_integral_exact, context=None)
2455 ans = str(Decimal('1.50001').quantize(exp=Decimal('1e-3'), rounding=None, context=None))
2458 ans = str(Decimal('1.50001').quantize(exp=Decimal('1e-3'), rounding=None, context=None))
2460 … ans = str(Decimal('1.50001').quantize(exp=Decimal('1e-3'), rounding=ROUND_UP, context=None))
2463 … self.assertRaises(InvalidOperation, y.quantize, Decimal('1e-10'), rounding=ROUND_UP, context=None)
2476 # Check that methods taking a second Decimal argument will
2477 # always accept an integer in place of a Decimal.
2478 Decimal = self.decimal.Decimal
2480 self.assertEqual(Decimal(4).compare(3),
2481 Decimal(4).compare(Decimal(3)))
2482 self.assertEqual(Decimal(4).compare_signal(3),
2483 Decimal(4).compare_signal(Decimal(3)))
2484 self.assertEqual(Decimal(4).compare_total(3),
2485 Decimal(4).compare_total(Decimal(3)))
2486 self.assertEqual(Decimal(4).compare_total_mag(3),
2487 Decimal(4).compare_total_mag(Decimal(3)))
2488 self.assertEqual(Decimal(10101).logical_and(1001),
2489 Decimal(10101).logical_and(Decimal(1001)))
2490 self.assertEqual(Decimal(10101).logical_or(1001),
2491 Decimal(10101).logical_or(Decimal(1001)))
2492 self.assertEqual(Decimal(10101).logical_xor(1001),
2493 Decimal(10101).logical_xor(Decimal(1001)))
2494 self.assertEqual(Decimal(567).max(123),
2495 Decimal(567).max(Decimal(123)))
2496 self.assertEqual(Decimal(567).max_mag(123),
2497 Decimal(567).max_mag(Decimal(123)))
2498 self.assertEqual(Decimal(567).min(123),
2499 Decimal(567).min(Decimal(123)))
2500 self.assertEqual(Decimal(567).min_mag(123),
2501 Decimal(567).min_mag(Decimal(123)))
2502 self.assertEqual(Decimal(567).next_toward(123),
2503 Decimal(567).next_toward(Decimal(123)))
2504 self.assertEqual(Decimal(1234).quantize(100),
2505 Decimal(1234).quantize(Decimal(100)))
2506 self.assertEqual(Decimal(768).remainder_near(1234),
2507 Decimal(768).remainder_near(Decimal(1234)))
2508 self.assertEqual(Decimal(123).rotate(1),
2509 Decimal(123).rotate(Decimal(1)))
2510 self.assertEqual(Decimal(1234).same_quantum(1000),
2511 Decimal(1234).same_quantum(Decimal(1000)))
2512 self.assertEqual(Decimal('9.123').scaleb(-100),
2513 Decimal('9.123').scaleb(Decimal(-100)))
2514 self.assertEqual(Decimal(456).shift(-1),
2515 Decimal(456).shift(Decimal(-1)))
2517 self.assertEqual(Decimal(-12).fma(Decimal(45), 67),
2518 Decimal(-12).fma(Decimal(45), Decimal(67)))
2519 self.assertEqual(Decimal(-12).fma(45, 67),
2520 Decimal(-12).fma(Decimal(45), Decimal(67)))
2521 self.assertEqual(Decimal(-12).fma(45, Decimal(67)),
2522 Decimal(-12).fma(Decimal(45), Decimal(67)))
2525 decimal = C variable in CUsabilityTest
2527 decimal = P variable in PyUsabilityTest
2541 Decimal = self.decimal.Decimal
2543 self.assertTrue(issubclass(Decimal, numbers.Number))
2544 self.assertFalse(issubclass(Decimal, numbers.Real))
2545 self.assertIsInstance(Decimal(0), numbers.Number)
2546 self.assertNotIsInstance(Decimal(0), numbers.Real)
2550 Decimal = self.decimal.Decimal
2552 savedecimal = sys.modules['decimal']
2555 sys.modules['decimal'] = self.decimal
2556 d = Decimal('-3.141590000')
2563 x = C.Decimal('-3.123e81723')
2564 y = P.Decimal('-3.123e81723')
2566 sys.modules['decimal'] = C
2568 sys.modules['decimal'] = P
2570 self.assertIsInstance(r, P.Decimal)
2573 sys.modules['decimal'] = P
2575 sys.modules['decimal'] = C
2577 self.assertIsInstance(r, C.Decimal)
2580 x = C.Decimal('-3.123e81723').as_tuple()
2581 y = P.Decimal('-3.123e81723').as_tuple()
2583 sys.modules['decimal'] = C
2585 sys.modules['decimal'] = P
2590 sys.modules['decimal'] = P
2592 sys.modules['decimal'] = C
2597 sys.modules['decimal'] = savedecimal
2600 Decimal = self.decimal.Decimal
2605 self.assertEqual(int(Decimal(s)), int(float(s)))
2607 d = Decimal(s)
2609 self.assertEqual(Decimal(int(d)), r)
2611 self.assertRaises(ValueError, int, Decimal('-nan'))
2612 self.assertRaises(ValueError, int, Decimal('snan'))
2613 self.assertRaises(OverflowError, int, Decimal('inf'))
2614 self.assertRaises(OverflowError, int, Decimal('-inf'))
2618 Decimal = self.decimal.Decimal
2621 self.assertIs(int(Decimal(x)), x)
2624 Decimal = self.decimal.Decimal
2629 self.assertEqual(int(Decimal(s)), int(float(s)))
2631 d = Decimal(s)
2633 self.assertEqual(Decimal(math.trunc(d)), r)
2637 Decimal = self.decimal.Decimal
2639 class MyDecimal(Decimal):
2643 self.assertTrue(issubclass(MyDecimal, Decimal))
2657 str(Decimal('NaN')))
2659 str(Decimal('Infinity')))
2661 str(Decimal('-Infinity')))
2668 Decimal = self.decimal.Decimal
2669 Context = self.decimal.Context
2670 Inexact = self.decimal.Inexact
2675 Decimal('3.1415')
2680 Decimal('3.1416')
2689 "Decimal('-0')")
2691 "Decimal('1')")
2693 "Decimal('10')")
2696 Decimal = self.decimal.Decimal
2697 Context = self.decimal.Context
2698 InvalidOperation = self.decimal.InvalidOperation
2702 Decimal('7.335').quantize(Decimal('.01')),
2703 Decimal('7.34')
2706 Decimal('7.335').quantize(Decimal('.01'), rounding=ROUND_DOWN),
2707 Decimal('7.33')
2711 Decimal("10e99999").quantize, Decimal('1e100000'), context=c
2715 d = Decimal("0.871831e800")
2716 x = d.quantize(context=c, exp=Decimal("1e797"), rounding=ROUND_DOWN)
2717 self.assertEqual(x, Decimal('8.71E+799'))
2720 Decimal = self.decimal.Decimal
2722 x = Decimal("9.8182731e181273")
2727 x = Decimal("1")
2736 D = self.decimal.Decimal
2737 Context = self.decimal.Context
2738 localcontext = self.decimal.localcontext
2739 InvalidOperation = self.decimal.InvalidOperation
2740 Overflow = self.decimal.Overflow
2849 decimal = self.decimal
2850 DecimalException = decimal.DecimalException
2851 InvalidOperation = decimal.InvalidOperation
2852 FloatOperation = decimal.FloatOperation
2853 DivisionByZero = decimal.DivisionByZero
2854 Overflow = decimal.Overflow
2855 Underflow = decimal.Underflow
2856 Subnormal = decimal.Subnormal
2857 Inexact = decimal.Inexact
2858 Rounded = decimal.Rounded
2859 Clamped = decimal.Clamped
2881 self.assertTrue(issubclass(decimal.ConversionSyntax, InvalidOperation))
2882 self.assertTrue(issubclass(decimal.DivisionImpossible, InvalidOperation))
2883 self.assertTrue(issubclass(decimal.DivisionUndefined, InvalidOperation))
2884 self.assertTrue(issubclass(decimal.DivisionUndefined, ZeroDivisionError))
2885 self.assertTrue(issubclass(decimal.InvalidContext, InvalidOperation))
2888 decimal = C variable in CPythonAPItests
2890 decimal = P variable in PyPythonAPItests
2895 Context = self.decimal.Context
2896 InvalidOperation = self.decimal.InvalidOperation
2897 DivisionByZero = self.decimal.DivisionByZero
2898 Overflow = self.decimal.Overflow
2919 c = self.decimal.Context()
2934 Context = self.decimal.Context
2936 savedecimal = sys.modules['decimal']
2939 sys.modules['decimal'] = self.decimal
2966 sys.modules['decimal'] = dumper
2977 sys.modules['decimal'] = loader
2990 sys.modules['decimal'] = savedecimal
2993 Decimal = self.decimal.Decimal
2995 self.assertIn(Decimal(10), ['a', 1.0, Decimal(10), (1,2), {}])
2996 self.assertNotIn(Decimal(10), ['a', 1.0, (1,2), {}])
3000 Decimal = self.decimal.Decimal
3001 Context = self.decimal.Context
3020 Context = self.decimal.Context
3025 Decimal = self.decimal.Decimal
3026 Context = self.decimal.Context
3029 d = c.abs(Decimal(-1))
3034 Decimal = self.decimal.Decimal
3035 Context = self.decimal.Context
3038 d = c.add(Decimal(1), Decimal(1))
3040 self.assertEqual(c.add(Decimal(1), 1), d)
3041 self.assertEqual(c.add(1, Decimal(1)), d)
3046 Decimal = self.decimal.Decimal
3047 Context = self.decimal.Context
3050 d = c.compare(Decimal(1), Decimal(1))
3052 self.assertEqual(c.compare(Decimal(1), 1), d)
3053 self.assertEqual(c.compare(1, Decimal(1)), d)
3058 Decimal = self.decimal.Decimal
3059 Context = self.decimal.Context
3062 d = c.compare_signal(Decimal(1), Decimal(1))
3064 self.assertEqual(c.compare_signal(Decimal(1), 1), d)
3065 self.assertEqual(c.compare_signal(1, Decimal(1)), d)
3070 Decimal = self.decimal.Decimal
3071 Context = self.decimal.Context
3074 d = c.compare_total(Decimal(1), Decimal(1))
3076 self.assertEqual(c.compare_total(Decimal(1), 1), d)
3077 self.assertEqual(c.compare_total(1, Decimal(1)), d)
3082 Decimal = self.decimal.Decimal
3083 Context = self.decimal.Context
3086 d = c.compare_total_mag(Decimal(1), Decimal(1))
3088 self.assertEqual(c.compare_total_mag(Decimal(1), 1), d)
3089 self.assertEqual(c.compare_total_mag(1, Decimal(1)), d)
3094 Decimal = self.decimal.Decimal
3095 Context = self.decimal.Context
3098 d = c.copy_abs(Decimal(-1))
3103 Decimal = self.decimal.Decimal
3104 Context = self.decimal.Context
3107 d = c.copy_decimal(Decimal(-1))
3112 Decimal = self.decimal.Decimal
3113 Context = self.decimal.Context
3116 d = c.copy_negate(Decimal(-1))
3121 Decimal = self.decimal.Decimal
3122 Context = self.decimal.Context
3125 d = c.copy_sign(Decimal(1), Decimal(-2))
3127 self.assertEqual(c.copy_sign(Decimal(1), -2), d)
3128 self.assertEqual(c.copy_sign(1, Decimal(-2)), d)
3133 Decimal = self.decimal.Decimal
3134 Context = self.decimal.Context
3137 d = c.divide(Decimal(1), Decimal(2))
3139 self.assertEqual(c.divide(Decimal(1), 2), d)
3140 self.assertEqual(c.divide(1, Decimal(2)), d)
3145 Decimal = self.decimal.Decimal
3146 Context = self.decimal.Context
3149 d = c.divide_int(Decimal(1), Decimal(2))
3151 self.assertEqual(c.divide_int(Decimal(1), 2), d)
3152 self.assertEqual(c.divide_int(1, Decimal(2)), d)
3157 Decimal = self.decimal.Decimal
3158 Context = self.decimal.Context
3161 d = c.divmod(Decimal(1), Decimal(2))
3163 self.assertEqual(c.divmod(Decimal(1), 2), d)
3164 self.assertEqual(c.divmod(1, Decimal(2)), d)
3169 Decimal = self.decimal.Decimal
3170 Context = self.decimal.Context
3173 d = c.exp(Decimal(10))
3178 Decimal = self.decimal.Decimal
3179 Context = self.decimal.Context
3182 d = c.fma(Decimal(2), Decimal(3), Decimal(4))
3184 self.assertEqual(c.fma(Decimal(2), 3, 4), d)
3185 self.assertEqual(c.fma(2, Decimal(3), 4), d)
3186 self.assertEqual(c.fma(2, 3, Decimal(4)), d)
3187 self.assertEqual(c.fma(Decimal(2), Decimal(3), 4), d)
3194 Decimal('Infinity'), Decimal(0), "not a decimal")
3196 Decimal(1), Decimal('snan'), 1.222)
3197 # ... and for Decimal.fma.
3198 self.assertRaises(TypeError, Decimal('Infinity').fma,
3199 Decimal(0), "not a decimal")
3200 self.assertRaises(TypeError, Decimal(1).fma,
3201 Decimal('snan'), 1.222)
3204 Decimal = self.decimal.Decimal
3205 Context = self.decimal.Context
3208 d = c.is_finite(Decimal(10))
3213 Decimal = self.decimal.Decimal
3214 Context = self.decimal.Context
3217 d = c.is_infinite(Decimal(10))
3222 Decimal = self.decimal.Decimal
3223 Context = self.decimal.Context
3226 d = c.is_nan(Decimal(10))
3231 Decimal = self.decimal.Decimal
3232 Context = self.decimal.Context
3235 d = c.is_normal(Decimal(10))
3240 Decimal = self.decimal.Decimal
3241 Context = self.decimal.Context
3244 d = c.is_qnan(Decimal(10))
3249 Decimal = self.decimal.Decimal
3250 Context = self.decimal.Context
3253 d = c.is_signed(Decimal(10))
3258 Decimal = self.decimal.Decimal
3259 Context = self.decimal.Context
3262 d = c.is_snan(Decimal(10))
3267 Decimal = self.decimal.Decimal
3268 Context = self.decimal.Context
3271 d = c.is_subnormal(Decimal(10))
3276 Decimal = self.decimal.Decimal
3277 Context = self.decimal.Context
3280 d = c.is_zero(Decimal(10))
3285 Decimal = self.decimal.Decimal
3286 Context = self.decimal.Context
3289 d = c.ln(Decimal(10))
3294 Decimal = self.decimal.Decimal
3295 Context = self.decimal.Context
3298 d = c.log10(Decimal(10))
3303 Decimal = self.decimal.Decimal
3304 Context = self.decimal.Context
3307 d = c.logb(Decimal(10))
3312 Decimal = self.decimal.Decimal
3313 Context = self.decimal.Context
3316 d = c.logical_and(Decimal(1), Decimal(1))
3318 self.assertEqual(c.logical_and(Decimal(1), 1), d)
3319 self.assertEqual(c.logical_and(1, Decimal(1)), d)
3324 Decimal = self.decimal.Decimal
3325 Context = self.decimal.Context
3328 d = c.logical_invert(Decimal(1000))
3333 Decimal = self.decimal.Decimal
3334 Context = self.decimal.Context
3337 d = c.logical_or(Decimal(1), Decimal(1))
3339 self.assertEqual(c.logical_or(Decimal(1), 1), d)
3340 self.assertEqual(c.logical_or(1, Decimal(1)), d)
3345 Decimal = self.decimal.Decimal
3346 Context = self.decimal.Context
3349 d = c.logical_xor(Decimal(1), Decimal(1))
3351 self.assertEqual(c.logical_xor(Decimal(1), 1), d)
3352 self.assertEqual(c.logical_xor(1, Decimal(1)), d)
3357 Decimal = self.decimal.Decimal
3358 Context = self.decimal.Context
3361 d = c.max(Decimal(1), Decimal(2))
3363 self.assertEqual(c.max(Decimal(1), 2), d)
3364 self.assertEqual(c.max(1, Decimal(2)), d)
3369 Decimal = self.decimal.Decimal
3370 Context = self.decimal.Context
3373 d = c.max_mag(Decimal(1), Decimal(2))
3375 self.assertEqual(c.max_mag(Decimal(1), 2), d)
3376 self.assertEqual(c.max_mag(1, Decimal(2)), d)
3381 Decimal = self.decimal.Decimal
3382 Context = self.decimal.Context
3385 d = c.min(Decimal(1), Decimal(2))
3387 self.assertEqual(c.min(Decimal(1), 2), d)
3388 self.assertEqual(c.min(1, Decimal(2)), d)
3393 Decimal = self.decimal.Decimal
3394 Context = self.decimal.Context
3397 d = c.min_mag(Decimal(1), Decimal(2))
3399 self.assertEqual(c.min_mag(Decimal(1), 2), d)
3400 self.assertEqual(c.min_mag(1, Decimal(2)), d)
3405 Decimal = self.decimal.Decimal
3406 Context = self.decimal.Context
3409 d = c.minus(Decimal(10))
3414 Decimal = self.decimal.Decimal
3415 Context = self.decimal.Context
3418 d = c.multiply(Decimal(1), Decimal(2))
3420 self.assertEqual(c.multiply(Decimal(1), 2), d)
3421 self.assertEqual(c.multiply(1, Decimal(2)), d)
3426 Decimal = self.decimal.Decimal
3427 Context = self.decimal.Context
3430 d = c.next_minus(Decimal(10))
3435 Decimal = self.decimal.Decimal
3436 Context = self.decimal.Context
3439 d = c.next_plus(Decimal(10))
3444 Decimal = self.decimal.Decimal
3445 Context = self.decimal.Context
3448 d = c.next_toward(Decimal(1), Decimal(2))
3450 self.assertEqual(c.next_toward(Decimal(1), 2), d)
3451 self.assertEqual(c.next_toward(1, Decimal(2)), d)
3456 Decimal = self.decimal.Decimal
3457 Context = self.decimal.Context
3460 d = c.normalize(Decimal(10))
3465 Decimal = self.decimal.Decimal
3466 Context = self.decimal.Context
3469 self.assertEqual(c.number_class(123), c.number_class(Decimal(123)))
3470 self.assertEqual(c.number_class(0), c.number_class(Decimal(0)))
3471 self.assertEqual(c.number_class(-45), c.number_class(Decimal(-45)))
3474 Decimal = self.decimal.Decimal
3475 Context = self.decimal.Context
3478 d = c.plus(Decimal(10))
3483 Decimal = self.decimal.Decimal
3484 Context = self.decimal.Context
3487 d = c.power(Decimal(1), Decimal(4))
3489 self.assertEqual(c.power(Decimal(1), 4), d)
3490 self.assertEqual(c.power(1, Decimal(4)), d)
3491 self.assertEqual(c.power(Decimal(1), Decimal(4)), d)
3497 Decimal = self.decimal.Decimal
3498 Context = self.decimal.Context
3501 d = c.quantize(Decimal(1), Decimal(2))
3503 self.assertEqual(c.quantize(Decimal(1), 2), d)
3504 self.assertEqual(c.quantize(1, Decimal(2)), d)
3509 Decimal = self.decimal.Decimal
3510 Context = self.decimal.Context
3513 d = c.remainder(Decimal(1), Decimal(2))
3515 self.assertEqual(c.remainder(Decimal(1), 2), d)
3516 self.assertEqual(c.remainder(1, Decimal(2)), d)
3521 Decimal = self.decimal.Decimal
3522 Context = self.decimal.Context
3525 d = c.remainder_near(Decimal(1), Decimal(2))
3527 self.assertEqual(c.remainder_near(Decimal(1), 2), d)
3528 self.assertEqual(c.remainder_near(1, Decimal(2)), d)
3533 Decimal = self.decimal.Decimal
3534 Context = self.decimal.Context
3537 d = c.rotate(Decimal(1), Decimal(2))
3539 self.assertEqual(c.rotate(Decimal(1), 2), d)
3540 self.assertEqual(c.rotate(1, Decimal(2)), d)
3545 Decimal = self.decimal.Decimal
3546 Context = self.decimal.Context
3549 d = c.sqrt(Decimal(10))
3554 Decimal = self.decimal.Decimal
3555 Context = self.decimal.Context
3558 d = c.same_quantum(Decimal(1), Decimal(2))
3560 self.assertEqual(c.same_quantum(Decimal(1), 2), d)
3561 self.assertEqual(c.same_quantum(1, Decimal(2)), d)
3566 Decimal = self.decimal.Decimal
3567 Context = self.decimal.Context
3570 d = c.scaleb(Decimal(1), Decimal(2))
3572 self.assertEqual(c.scaleb(Decimal(1), 2), d)
3573 self.assertEqual(c.scaleb(1, Decimal(2)), d)
3578 Decimal = self.decimal.Decimal
3579 Context = self.decimal.Context
3582 d = c.shift(Decimal(1), Decimal(2))
3584 self.assertEqual(c.shift(Decimal(1), 2), d)
3585 self.assertEqual(c.shift(1, Decimal(2)), d)
3590 Decimal = self.decimal.Decimal
3591 Context = self.decimal.Context
3594 d = c.subtract(Decimal(1), Decimal(2))
3596 self.assertEqual(c.subtract(Decimal(1), 2), d)
3597 self.assertEqual(c.subtract(1, Decimal(2)), d)
3602 Decimal = self.decimal.Decimal
3603 Context = self.decimal.Context
3606 d = c.to_eng_string(Decimal(10))
3611 Decimal = self.decimal.Decimal
3612 Context = self.decimal.Context
3615 d = c.to_sci_string(Decimal(10))
3620 Decimal = self.decimal.Decimal
3621 Context = self.decimal.Context
3624 d = c.to_integral_exact(Decimal(10))
3629 Decimal = self.decimal.Decimal
3630 Context = self.decimal.Context
3633 d = c.to_integral_value(Decimal(10))
3639 decimal = C variable in CContextAPItests
3641 decimal = P variable in PyContextAPItests
3649 getcontext = self.decimal.getcontext
3650 localcontext = self.decimal.localcontext
3662 Context = self.decimal.Context
3663 getcontext = self.decimal.getcontext
3664 localcontext = self.decimal.localcontext
3666 localcontext = self.decimal.localcontext
3678 with self.decimal.localcontext(
3684 self.assertEqual(ctx.rounding, self.decimal.ROUND_HALF_DOWN)
3690 self.assertRaises(TypeError, self.decimal.localcontext, precision=10)
3692 self.assertRaises(ValueError, self.decimal.localcontext, Emin=1)
3693 self.assertRaises(ValueError, self.decimal.localcontext, Emax=-1)
3694 self.assertRaises(ValueError, self.decimal.localcontext, capitals=2)
3695 self.assertRaises(ValueError, self.decimal.localcontext, clamp=2)
3697 self.assertRaises(TypeError, self.decimal.localcontext, rounding="")
3698 self.assertRaises(TypeError, self.decimal.localcontext, rounding=1)
3700 self.assertRaises(TypeError, self.decimal.localcontext, flags="")
3701 self.assertRaises(TypeError, self.decimal.localcontext, traps="")
3702 self.assertRaises(TypeError, self.decimal.localcontext, Emin="")
3703 self.assertRaises(TypeError, self.decimal.localcontext, Emax="")
3706 ctx = self.decimal.getcontext()
3708 with self.decimal.localcontext(prec=10) as ctx2:
3713 Decimal = self.decimal.Decimal
3714 Context = self.decimal.Context
3715 getcontext = self.decimal.getcontext
3716 localcontext = self.decimal.localcontext
3717 Clamped = self.decimal.Clamped
3718 Overflow = self.decimal.Overflow
3734 self.assertRaises(Overflow, c2.power, Decimal('3.4e200'), 2)
3747 localcontext = self.decimal.localcontext
3759 localcontext = self.decimal.localcontext
3771 Context = self.decimal.Context
3772 localcontext = self.decimal.localcontext
3773 getcontext = self.decimal.getcontext
3774 setcontext = self.decimal.setcontext
3804 decimal = C variable in CContextWithStatement
3806 decimal = P variable in PyContextWithStatement
3813 Decimal = self.decimal.Decimal
3814 Context = self.decimal.Context
3815 Inexact = self.decimal.Inexact
3816 Rounded = self.decimal.Rounded
3817 Underflow = self.decimal.Underflow
3818 Clamped = self.decimal.Clamped
3819 Subnormal = self.decimal.Subnormal
3822 if self.decimal == C:
3834 (context._apply, [Decimal("100E-425000010")]),
3835 (context.sqrt, [Decimal(2)]),
3836 (context.add, [Decimal("1.23456789"), Decimal("9.87654321")]),
3837 (context.multiply, [Decimal("1.23456789"), Decimal("9.87654321")]),
3838 (context.subtract, [Decimal("1.23456789"), Decimal("9.87654321")]),
3877 Context = self.decimal.Context
3878 Inexact = self.decimal.Inexact
3879 Rounded = self.decimal.Rounded
3916 Decimal = self.decimal.Decimal
3917 FloatOperation = self.decimal.FloatOperation
3918 localcontext = self.decimal.localcontext
3926 self.assertEqual(Decimal(7.5), 7.5)
3935 x = Decimal.from_float(7.5)
3952 self.assertRaises(FloatOperation, Decimal, 7.5)
3961 x = Decimal.from_float(7.5)
3969 Decimal = self.decimal.Decimal
3970 Context = self.decimal.Context
3971 FloatOperation = self.decimal.FloatOperation
3972 localcontext = self.decimal.localcontext
3983 small_d = Decimal('0.25')
3984 big_d = Decimal('3.0')
3988 zero_d = Decimal('0.0')
3989 neg_zero_d = Decimal('-0.0')
3993 inf_d = Decimal('Infinity')
3994 neg_inf_d = Decimal('-Infinity')
4021 assert_attr(Decimal('0.1'), 0.1, '__ne__', c, None)
4026 assert_attr(Decimal('NaN'), float('nan'), '__ne__', c, None)
4030 s = set([100.0, Decimal('100.0')])
4036 self.assertRaises(signal, sorted, [1.0, Decimal('10.0')])
4038 s = sorted([10.0, Decimal('10.0')])
4042 b = 10.0 in [Decimal('10.0'), 1.0]
4046 b = 10.0 in {Decimal('10.0'):'a', 1.0:'b'}
4060 Decimal = self.decimal.Decimal
4061 Context = self.decimal.Context
4062 Inexact = self.decimal.Inexact
4063 FloatOperation= self.decimal.FloatOperation
4076 decimal = C variable in CContextFlags
4078 decimal = P variable in PyContextFlags
4084 BasicContext = self.decimal.BasicContext
4085 ExtendedContext = self.decimal.ExtendedContext
4086 getcontext = self.decimal.getcontext
4087 setcontext = self.decimal.setcontext
4088 InvalidOperation = self.decimal.InvalidOperation
4089 DivisionByZero = self.decimal.DivisionByZero
4090 Overflow = self.decimal.Overflow
4091 Underflow = self.decimal.Underflow
4092 Clamped = self.decimal.Clamped
4120 DefaultContext = self.decimal.DefaultContext
4121 BasicContext = self.decimal.BasicContext
4122 ExtendedContext = self.decimal.ExtendedContext
4123 getcontext = self.decimal.getcontext
4124 setcontext = self.decimal.setcontext
4125 InvalidOperation = self.decimal.InvalidOperation
4126 DivisionByZero = self.decimal.DivisionByZero
4127 Overflow = self.decimal.Overflow
4161 decimal = C variable in CSpecialContexts
4163 decimal = P variable in PySpecialContexts
4168 Context = self.decimal.Context
4169 DefaultContext = self.decimal.DefaultContext
4228 decimal = C variable in CContextInputValidation
4230 decimal = P variable in PyContextInputValidation
4235 decimal = self.decimal
4236 Decimal = decimal.Decimal
4237 Context = decimal.Context
4238 Clamped = decimal.Clamped
4239 DivisionByZero = decimal.DivisionByZero
4240 Inexact = decimal.Inexact
4241 Overflow = decimal.Overflow
4242 Rounded = decimal.Rounded
4243 Subnormal = decimal.Subnormal
4244 Underflow = decimal.Underflow
4245 InvalidOperation = decimal.InvalidOperation
4266 flags = {v:(v in flags) for v in OrderedSignals[decimal] + flags}
4270 traps = {v:(v in traps) for v in OrderedSignals[decimal] + traps}
4283 self.assertRaises(InvalidOperation, c.quantize, Decimal('9e2'), 0)
4289 self.assertEqual(c.plus(Decimal('9.9')), 9)
4295 x = c.add(Decimal('1e-99'), Decimal('2.234e-2000'))
4296 self.assertEqual(x, Decimal('0.0'))
4304 self.assertRaises(Overflow, c.add, Decimal('1e99'), Decimal('2.234e2000'))
4305 if self.decimal == C:
4320 x = c.plus(Decimal('1e99'))
4329 for signal in OrderedSignals[decimal]:
4338 for signal in OrderedSignals[decimal]:
4342 decimal = C variable in CContextSubclassing
4344 decimal = P variable in PyContextSubclassing
4372 x = [s for s in dir(C.Decimal(9)) if '__' in s or not s.startswith('_')]
4373 y = [s for s in dir(C.Decimal(9)) if '__' in s or not s.startswith('_')]
4379 Decimal = self.decimal.Decimal
4381 self.assertEqual(Decimal('1234e9999').adjusted(), 10002)
4383 self.assertEqual(Decimal('nan').adjusted(), 0)
4384 self.assertEqual(Decimal('inf').adjusted(), 0)
4387 Decimal = self.decimal.Decimal
4388 getcontext = self.decimal.getcontext
4390 x = Decimal(9).canonical()
4394 x = c.canonical(Decimal(9))
4398 c = self.decimal.DefaultContext.copy()
4406 for sig in OrderedSignals[self.decimal]:
4417 Decimal = self.decimal.Decimal
4418 localcontext = self.decimal.localcontext
4426 self.assertEqual(abs(Decimal("-10")), 10)
4428 self.assertEqual(Decimal("7") + 1, 8)
4430 self.assertEqual(Decimal("10") / 5, 2)
4432 self.assertEqual(Decimal("10") // 7, 1)
4434 self.assertEqual(Decimal("1.2").fma(Decimal("0.01"), 1), 1)
4435 self.assertIs(Decimal("NaN").fma(7, 1).is_nan(), True)
4437 self.assertEqual(pow(Decimal(10), 2, 7), 2)
4439 self.assertEqual(Decimal("1.01").exp(), 3)
4441 self.assertIs(Decimal("0.01").is_normal(), False)
4443 self.assertIs(Decimal("0.01").is_subnormal(), True)
4445 self.assertEqual(Decimal("20").ln(), 3)
4447 self.assertEqual(Decimal("20").log10(), 1)
4449 self.assertEqual(Decimal("580").logb(), 2)
4451 self.assertEqual(Decimal("10").logical_invert(), 1)
4453 self.assertEqual(-Decimal("-10"), 10)
4455 self.assertEqual(Decimal("2") * 4, 8)
4457 self.assertEqual(Decimal("10").next_minus(), 9)
4459 self.assertEqual(Decimal("10").next_plus(), Decimal('2E+1'))
4461 self.assertEqual(Decimal("-10").normalize(), Decimal('-1E+1'))
4463 self.assertEqual(Decimal("10").number_class(), '+Normal')
4465 self.assertEqual(+Decimal("-1"), -1)
4467 self.assertEqual(Decimal("10") % 7, 3)
4469 self.assertEqual(Decimal("10") - 7, 3)
4471 self.assertEqual(Decimal("1.12345").to_integral_exact(), 1)
4474 self.assertTrue(Decimal("1").is_canonical())
4475 self.assertTrue(Decimal("1").is_finite())
4476 self.assertTrue(Decimal("1").is_finite())
4477 self.assertTrue(Decimal("snan").is_snan())
4478 self.assertTrue(Decimal("-1").is_signed())
4479 self.assertTrue(Decimal("0").is_zero())
4480 self.assertTrue(Decimal("0").is_zero())
4486 y = -Decimal(x)
4494 z = y.copy_sign(Decimal(1))
4498 Decimal = self.decimal.Decimal
4499 localcontext = self.decimal.localcontext
4500 InvalidOperation = self.decimal.InvalidOperation
4501 DivisionByZero = self.decimal.DivisionByZero
4504 q, r = divmod(Decimal("10912837129"), 1001)
4505 self.assertEqual(q, Decimal('10901935'))
4506 self.assertEqual(r, Decimal('194'))
4508 q, r = divmod(Decimal("NaN"), 7)
4512 q, r = divmod(Decimal("NaN"), 7)
4517 q, r = divmod(Decimal("inf"), Decimal("inf"))
4522 q, r = divmod(Decimal("inf"), 101)
4527 q, r = divmod(Decimal(0), 0)
4533 q, r = divmod(Decimal(11), 0)
4539 Decimal = self.decimal.Decimal
4540 localcontext = self.decimal.localcontext
4541 Overflow = self.decimal.Overflow
4542 Rounded = self.decimal.Rounded
4547 self.assertEqual(Decimal("1.0") ** 100, Decimal('1.00'))
4555 self.assertEqual(Decimal(10000) ** Decimal("0.5"), Decimal('inf'))
4559 Decimal = self.decimal.Decimal
4560 localcontext = self.decimal.localcontext
4561 InvalidOperation = self.decimal.InvalidOperation
4568 x = Decimal(99).quantize(Decimal("1e1"))
4572 Decimal = self.decimal.Decimal
4573 getcontext = self.decimal.getcontext
4576 self.assertEqual(Decimal("1").radix(), 10)
4580 Decimal = self.decimal.Decimal
4584 self.assertIs(getattr(Decimal("1"), attr)("xyz"), NotImplemented)
4587 # Python3 behavior: round() returns Decimal
4588 Decimal = self.decimal.Decimal
4589 localcontext = self.decimal.localcontext
4594 self.assertEqual(str(Decimal("9.99").__round__()), "10")
4595 self.assertEqual(str(Decimal("9.99e-5").__round__()), "0")
4596 self.assertEqual(str(Decimal("1.23456789").__round__(5)), "1.23457")
4597 self.assertEqual(str(Decimal("1.2345").__round__(10)), "1.2345000000")
4598 self.assertEqual(str(Decimal("1.2345").__round__(-10)), "0E+10")
4600 self.assertRaises(TypeError, Decimal("1.23").__round__, "5")
4601 self.assertRaises(TypeError, Decimal("1.23").__round__, 5, 8)
4604 c = self.decimal.Context()
4608 Decimal = self.decimal.Decimal
4609 localcontext = self.decimal.localcontext
4613 x = Decimal(1221**1271) / 10**3923
4618 Context = self.decimal.Context
4634 decimal = C variable in CCoverage
4636 decimal = P variable in PyCoverage
4648 """Extra functionality in decimal.py"""
4651 # triples giving a format, a Decimal, and the expected result
4652 Decimal = P.Decimal
4669 self.assertEqual(format(Decimal(d), fmt), result)
4672 """White box testing for decimal.py"""
4676 Decimal = P.Decimal
4681 x = Decimal(2**16) ** Decimal("-0.5")
4682 self.assertEqual(x, Decimal('0.00390625'))
4684 x = Decimal(2**16) ** Decimal("-0.6")
4685 self.assertEqual(x, Decimal('0.0012885819'))
4687 x = Decimal("256e7") ** Decimal("-0.5")
4689 x = Decimal(152587890625) ** Decimal('-0.0625')
4690 self.assertEqual(x, Decimal("0.2"))
4692 x = Decimal("152587890625e7") ** Decimal('-0.0625')
4694 x = Decimal(5**2659) ** Decimal('-0.0625')
4697 x = Decimal("152587890625") ** Decimal('-0.5')
4699 x = Decimal(2**578) ** Decimal("-0.5")
4703 Decimal = P.Decimal
4711 d1 = Decimal('-25e55')
4712 b1 = Decimal('-25e55')
4713 d2 = Decimal('33e+33')
4714 b2 = Decimal('33e+33')
4731 Decimal(d1)
4781 Decimal = P.Decimal
4783 d = Decimal(45)
4784 e = Decimal(d)
4790 Decimal = P.Decimal
4794 x = Decimal("NaN")._rescale(3, ROUND_UP)
4799 Decimal = P.Decimal
4801 self.assertRaises(ValueError, Decimal("3.1234")._round, 0, ROUND_UP)
4808 # issue 8786: Add support for IEEE 754 contexts to decimal module.
4894 Decimal = C.Decimal
4905 y = Decimal(a) ** Decimal(b)
4909 self.assertRaises(TypeError, C.Decimal, 9, "xyz")
4913 Decimal = C.Decimal
4919 self.assertRaises(InvalidOperation, Decimal,
5155 Decimal = C.Decimal
5164 self.assertRaises(InvalidOperation, Decimal("1.23").__round__,
5166 self.assertRaises(InvalidOperation, Decimal("1.23").__round__,
5168 self.assertRaises(InvalidOperation, Decimal("1").__round__,
5170 self.assertRaises(C.InvalidOperation, Decimal("1").__round__,
5172 self.assertRaises(OverflowError, Decimal("1.23").__round__,
5174 self.assertRaises(OverflowError, Decimal("1.23").__round__,
5179 Decimal = C.Decimal
5182 self.assertRaises(TypeError, Decimal(1).__format__, "=10.10", [], 9)
5183 self.assertRaises(TypeError, Decimal(1).__format__, "=10.10", 9)
5184 self.assertRaises(TypeError, Decimal(1).__format__, [])
5186 self.assertRaises(ValueError, Decimal(1).__format__, "<>=10.10")
5188 self.assertRaises(ValueError, Decimal("1.23456789").__format__,
5192 Decimal = C.Decimal
5196 x = Decimal(10)
5213 x = Decimal("99999999999999999999999999.9").to_integral_value(ROUND_UP)
5214 self.assertEqual(x, Decimal('100000000000000000000000000'))
5216 x = Decimal("99999999999999999999999999.9").to_integral_exact(ROUND_UP)
5217 self.assertEqual(x, Decimal('100000000000000000000000000'))
5220 self.assertRaises(Inexact, Decimal("999.9").to_integral_exact, ROUND_UP)
5224 Decimal = C.Decimal
5230 self.assertEqual(Decimal('9.99e10').to_eng_string(), '99.9E+9')
5232 self.assertRaises(TypeError, pow, Decimal(1), 2, "3")
5233 self.assertRaises(TypeError, Decimal(9).number_class, "x", "y")
5234 self.assertRaises(TypeError, Decimal(9).same_quantum, 3, "x", "y")
5238 Decimal("1.23456789").quantize, Decimal('1e-100000'), []
5242 Decimal("1.23456789").quantize, Decimal('1e-100000'), getcontext()
5246 Decimal("1.23456789").quantize, Decimal('1e-100000'), 10
5250 Decimal("1.23456789").quantize, Decimal('1e-100000'), ROUND_UP, 1000
5257 self.assertRaises(TypeError, c.copy_sign, Decimal(1), "x", "y")
5263 self.assertEqual(str(c.canonical(Decimal(200))), '200')
5267 self.assertRaises(DivisionByZero, Decimal(9).__divmod__, 0)
5273 self.assertRaises(InvalidOperation, Decimal(9).__divmod__, 0)
5279 self.assertRaises(InvalidOperation, pow, Decimal(1000), 1, 501)
5282 Decimal = C.Decimal
5285 x = Decimal("10001111111")
5472 Decimal = C.Decimal
5483 return Decimal(x).__format__(fmt, override)
5509 Decimal = C.Decimal
5519 self.assertRaises(InvalidOperation, Decimal, x)
5522 self.assertRaises(InvalidOperation, Decimal, x)
5526 self.assertRaises(InvalidOperation, Decimal, x)
5530 self.assertRaises(InvalidOperation, Decimal, x)
5533 Decimal = C.Decimal
5549 self.assertRaises(InvalidOperation, Decimal, x)
5553 self.assertRaises(InvalidOperation, Decimal, x)
5558 self.assertRaises(InvalidOperation, Decimal, x)
5562 self.assertRaises(InvalidOperation, Decimal, x)
5567 self.assertRaises(OverflowError, Decimal, x)
5571 self.assertRaises(OverflowError, Decimal, x)
5575 self.assertEqual(str(Decimal(x)), '-sNaN')
5577 self.assertEqual(str(Decimal(x)), '-sNaN')
5579 self.assertEqual(str(Decimal(x)), '-sNaN1')
5582 Decimal = C.Decimal
5585 self.assertGreater(Decimal(0).__sizeof__(), 0)
5587 x = Decimal(10**(19*24)).__sizeof__()
5588 y = Decimal(10**(19*25)).__sizeof__()
5591 x = Decimal(10**(9*24)).__sizeof__()
5592 y = Decimal(10**(9*25)).__sizeof__()
5596 Decimal = C.Decimal
5620 self.assertEqual(Decimal.from_float(cls(101.1)),
5621 Decimal.from_float(101.1))
5643 Decimal = C.Decimal
5651 self.assertEqual(Decimal(0).exp(), 1)
5652 self.assertEqual(Decimal(1).ln(), 0)
5653 self.assertEqual(Decimal(1).log10(), 0)
5654 self.assertEqual(Decimal(10**2).log10(), 2)
5655 self.assertEqual(Decimal(10**223).log10(), 223)
5656 self.assertEqual(Decimal(10**19).logb(), 19)
5657 self.assertEqual(Decimal(4).sqrt(), 2)
5658 self.assertEqual(Decimal("40E9").sqrt(), Decimal('2.0E+5'))
5659 self.assertEqual(divmod(Decimal(10), 3), (3, 1))
5660 self.assertEqual(Decimal(10) // 3, 3)
5661 self.assertEqual(Decimal(4) / 2, 2)
5662 self.assertEqual(Decimal(400) ** -1, Decimal('0.0025'))
5676 if (attr == 'Decimal' or attr == 'Context' or
5704 pdict = {C: {'other': C.Decimal(1),
5705 'third': C.Decimal(1),
5706 'x': C.Decimal(1),
5707 'y': C.Decimal(1),
5708 'z': C.Decimal(1),
5709 'a': C.Decimal(1),
5710 'b': C.Decimal(1),
5711 'c': C.Decimal(1),
5712 'exp': C.Decimal(1),
5713 'modulo': C.Decimal(1),
5718 P: {'other': P.Decimal(1),
5719 'third': P.Decimal(1),
5720 'a': P.Decimal(1),
5721 'b': P.Decimal(1),
5722 'c': P.Decimal(1),
5723 'exp': P.Decimal(1),
5724 'modulo': P.Decimal(1),
5778 if ty == 'Decimal':
5798 doit('Decimal')
5833 Runs all arithmetic tests if arith is True or if the "decimal" resource
5840 TEST_ALL = arith if arith is not None else is_resource_enabled('decimal')
5867 savedecimal = sys.modules['decimal']
5869 sys.modules['decimal'] = C
5871 sys.modules['decimal'] = P
5873 sys.modules['decimal'] = savedecimal
5880 if not orig_sys_decimal is sys.modules['decimal']:
5882 "sys.modules['decimal'].")