Changeset 391 for python/trunk/Lib/test/test_complex.py
- Timestamp:
- Mar 19, 2014, 11:31:01 PM (11 years ago)
- Location:
- python/trunk
- Files:
-
- 2 edited
-
. (modified) (1 prop)
-
Lib/test/test_complex.py (modified) (14 diffs)
Legend:
- Unmodified
- Added
- Removed
-
python/trunk
-
Property svn:mergeinfo
set to
/python/vendor/Python-2.7.6 merged eligible /python/vendor/current merged eligible
-
Property svn:mergeinfo
set to
-
python/trunk/Lib/test/test_complex.py
r2 r391 1 import unittest , os1 import unittest 2 2 from test import test_support 3 3 4 import warnings5 warnings.filterwarnings(6 "ignore",7 category=DeprecationWarning,8 message=".*complex divmod.*are deprecated"9 )10 11 4 from random import random 12 from math import atan2 5 from math import atan2, isnan, copysign 13 6 14 7 INF = float("inf") … … 43 36 return abs(y) < eps 44 37 # check that relative difference < eps 45 self.assert_(abs((x-y)/y) < eps) 38 self.assertTrue(abs((x-y)/y) < eps) 39 40 def assertFloatsAreIdentical(self, x, y): 41 """assert that floats x and y are identical, in the sense that: 42 (1) both x and y are nans, or 43 (2) both x and y are infinities, with the same sign, or 44 (3) both x and y are zeros, with the same sign, or 45 (4) x and y are both finite and nonzero, and x == y 46 47 """ 48 msg = 'floats {!r} and {!r} are not identical' 49 50 if isnan(x) or isnan(y): 51 if isnan(x) and isnan(y): 52 return 53 elif x == y: 54 if x != 0.0: 55 return 56 # both zero; check that signs match 57 elif copysign(1.0, x) == copysign(1.0, y): 58 return 59 else: 60 msg += ': zeros have different signs' 61 self.fail(msg.format(x, y)) 46 62 47 63 def assertClose(self, x, y, eps=1e-9): … … 49 65 self.assertCloseAbs(x.real, y.real, eps) 50 66 self.assertCloseAbs(x.imag, y.imag, eps) 51 52 def assertIs(self, a, b):53 self.assert_(a is b)54 67 55 68 def check_div(self, x, y): … … 103 116 self.assertRaises(OverflowError, complex.__coerce__, 1+1j, 1L<<10000) 104 117 118 def test_no_implicit_coerce(self): 119 # Python 2.7 removed implicit coercion from the complex type 120 class A(object): 121 def __coerce__(self, other): 122 raise RuntimeError 123 __hash__ = None 124 def __cmp__(self, other): 125 return -1 126 127 a = A() 128 self.assertRaises(TypeError, lambda: a + 2.0j) 129 self.assertTrue(a < 2.0j) 130 105 131 def test_richcompare(self): 106 self.assert Raises(OverflowError, complex.__eq__, 1+1j, 1L<<10000)132 self.assertEqual(complex.__eq__(1+1j, 1L<<10000), False) 107 133 self.assertEqual(complex.__lt__(1+1j, None), NotImplemented) 108 134 self.assertIs(complex.__eq__(1+1j, 1+1j), True) … … 115 141 self.assertRaises(TypeError, complex.__ge__, 1+1j, 2+2j) 116 142 143 def test_richcompare_boundaries(self): 144 def check(n, deltas, is_equal, imag = 0.0): 145 for delta in deltas: 146 i = n + delta 147 z = complex(i, imag) 148 self.assertIs(complex.__eq__(z, i), is_equal(delta)) 149 self.assertIs(complex.__ne__(z, i), not is_equal(delta)) 150 # For IEEE-754 doubles the following should hold: 151 # x in [2 ** (52 + i), 2 ** (53 + i + 1)] -> x mod 2 ** i == 0 152 # where the interval is representable, of course. 153 for i in range(1, 10): 154 pow = 52 + i 155 mult = 2 ** i 156 check(2 ** pow, range(1, 101), lambda delta: delta % mult == 0) 157 check(2 ** pow, range(1, 101), lambda delta: False, float(i)) 158 check(2 ** 53, range(-100, 0), lambda delta: True) 159 117 160 def test_mod(self): 118 161 self.assertRaises(ZeroDivisionError, (1+1j).__mod__, 0+0j) … … 170 213 def test_boolcontext(self): 171 214 for i in xrange(100): 172 self.assert _(complex(random() + 1e-6, random() + 1e-6))173 self.assert _(not complex(0.0, 0.0))215 self.assertTrue(complex(random() + 1e-6, random() + 1e-6)) 216 self.assertTrue(not complex(0.0, 0.0)) 174 217 175 218 def test_conjugate(self): … … 221 264 self.assertAlmostEqual(complex("(1+2j)"), 1+2j) 222 265 self.assertAlmostEqual(complex("(1.3+2.2j)"), 1.3+2.2j) 223 self.assertAlmostEqual(complex("1E-500"), 1e-500+0j) 224 self.assertAlmostEqual(complex("1e-500J"), 1e-500j) 225 self.assertAlmostEqual(complex("+1e-315-1e-400j"), 1e-315-1e-400j) 266 self.assertAlmostEqual(complex("3.14+1J"), 3.14+1j) 267 self.assertAlmostEqual(complex(" ( +3.14-6J )"), 3.14-6j) 268 self.assertAlmostEqual(complex(" ( +3.14-J )"), 3.14-1j) 269 self.assertAlmostEqual(complex(" ( +3.14+j )"), 3.14+1j) 270 self.assertAlmostEqual(complex("J"), 1j) 271 self.assertAlmostEqual(complex("( j )"), 1j) 272 self.assertAlmostEqual(complex("+J"), 1j) 273 self.assertAlmostEqual(complex("( -j)"), -1j) 274 self.assertAlmostEqual(complex('1e-500'), 0.0 + 0.0j) 275 self.assertAlmostEqual(complex('-1e-500j'), 0.0 - 0.0j) 276 self.assertAlmostEqual(complex('-1e-500+1e-500j'), -0.0 + 0.0j) 226 277 227 278 class complex2(complex): pass … … 245 296 246 297 c = 3.14 + 1j 247 self.assert _(complex(c) is c)298 self.assertTrue(complex(c) is c) 248 299 del c 249 300 … … 251 302 self.assertRaises(TypeError, complex, 1, "1") 252 303 253 self.assertEqual(complex(" 3.14+J "), 3.14+1j)254 304 if test_support.have_unicode: 255 305 self.assertEqual(complex(unicode(" 3.14+J ")), 3.14+1j) … … 277 327 self.assertRaises(ValueError, complex, "(1+2j)123") 278 328 if test_support.have_unicode: 279 self.assertRaises(ValueError, complex, unicode("1"*500))280 329 self.assertRaises(ValueError, complex, unicode("x")) 330 self.assertRaises(ValueError, complex, "1j+2") 331 self.assertRaises(ValueError, complex, "1e1ej") 332 self.assertRaises(ValueError, complex, "1e++1ej") 333 self.assertRaises(ValueError, complex, ")1+2j(") 334 # the following three are accepted by Python 2.6 335 self.assertRaises(ValueError, complex, "1..1j") 336 self.assertRaises(ValueError, complex, "1.11.1j") 337 self.assertRaises(ValueError, complex, "1e1.1j") 338 339 if test_support.have_unicode: 340 # check that complex accepts long unicode strings 341 self.assertEqual(type(complex(unicode("1"*500))), complex) 281 342 282 343 class EvilExc(Exception): … … 321 382 self.assertRaises(TypeError, complex, complex2(1j)) 322 383 384 def test_subclass(self): 385 class xcomplex(complex): 386 def __add__(self,other): 387 return xcomplex(complex(self) + other) 388 __radd__ = __add__ 389 390 def __sub__(self,other): 391 return xcomplex(complex(self) + other) 392 __rsub__ = __sub__ 393 394 def __mul__(self,other): 395 return xcomplex(complex(self) * other) 396 __rmul__ = __mul__ 397 398 def __div__(self,other): 399 return xcomplex(complex(self) / other) 400 401 def __rdiv__(self,other): 402 return xcomplex(other / complex(self)) 403 404 __truediv__ = __div__ 405 __rtruediv__ = __rdiv__ 406 407 def __floordiv__(self,other): 408 return xcomplex(complex(self) // other) 409 410 def __rfloordiv__(self,other): 411 return xcomplex(other // complex(self)) 412 413 def __pow__(self,other): 414 return xcomplex(complex(self) ** other) 415 416 def __rpow__(self,other): 417 return xcomplex(other ** complex(self) ) 418 419 def __mod__(self,other): 420 return xcomplex(complex(self) % other) 421 422 def __rmod__(self,other): 423 return xcomplex(other % complex(self)) 424 425 infix_binops = ('+', '-', '*', '**', '%', '//', '/') 426 xcomplex_values = (xcomplex(1), xcomplex(123.0), 427 xcomplex(-10+2j), xcomplex(3+187j), 428 xcomplex(3-78j)) 429 test_values = (1, 123.0, 10-19j, xcomplex(1+2j), 430 xcomplex(1+87j), xcomplex(10+90j)) 431 432 for op in infix_binops: 433 for x in xcomplex_values: 434 for y in test_values: 435 a = 'x %s y' % op 436 b = 'y %s x' % op 437 self.assertTrue(type(eval(a)) is type(eval(b)) is xcomplex) 438 323 439 def test_hash(self): 324 440 for x in xrange(-30, 30): … … 343 459 self.assertEqual(6j,complex(repr(6j))) 344 460 345 self.assertEqual(repr(complex(1., INF)), "(1+inf *j)")346 self.assertEqual(repr(complex(1., -INF)), "(1-inf *j)")461 self.assertEqual(repr(complex(1., INF)), "(1+infj)") 462 self.assertEqual(repr(complex(1., -INF)), "(1-infj)") 347 463 self.assertEqual(repr(complex(INF, 1)), "(inf+1j)") 348 self.assertEqual(repr(complex(-INF, INF)), "(-inf+inf *j)")464 self.assertEqual(repr(complex(-INF, INF)), "(-inf+infj)") 349 465 self.assertEqual(repr(complex(NAN, 1)), "(nan+1j)") 350 self.assertEqual(repr(complex(1, NAN)), "(1+nan *j)")351 self.assertEqual(repr(complex(NAN, NAN)), "(nan+nan *j)")352 353 self.assertEqual(repr(complex(0, INF)), "inf *j")354 self.assertEqual(repr(complex(0, -INF)), "-inf *j")355 self.assertEqual(repr(complex(0, NAN)), "nan *j")466 self.assertEqual(repr(complex(1, NAN)), "(1+nanj)") 467 self.assertEqual(repr(complex(NAN, NAN)), "(nan+nanj)") 468 469 self.assertEqual(repr(complex(0, INF)), "infj") 470 self.assertEqual(repr(complex(0, -INF)), "-infj") 471 self.assertEqual(repr(complex(0, NAN)), "nanj") 356 472 357 473 def test_neg(self): … … 372 488 if (fo is not None) and (not fo.closed): 373 489 fo.close() 374 try: 375 os.remove(test_support.TESTFN) 376 except (OSError, IOError): 377 pass 490 test_support.unlink(test_support.TESTFN) 378 491 379 492 def test_getnewargs(self): … … 389 502 # test that -0j and 0j literals are not identified 390 503 z1, z2 = 0j, -0j 391 self.assertEquals(atan2(z1.imag, -1.), atan2(0., -1.)) 392 self.assertEquals(atan2(z2.imag, -1.), atan2(-0., -1.)) 504 self.assertEqual(atan2(z1.imag, -1.), atan2(0., -1.)) 505 self.assertEqual(atan2(z2.imag, -1.), atan2(-0., -1.)) 506 507 @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"), 508 "test requires IEEE 754 doubles") 509 def test_overflow(self): 510 self.assertEqual(complex("1e500"), complex(INF, 0.0)) 511 self.assertEqual(complex("-1e500j"), complex(0.0, -INF)) 512 self.assertEqual(complex("-1e500+1.8e308j"), complex(-INF, INF)) 513 514 @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"), 515 "test requires IEEE 754 doubles") 516 def test_repr_roundtrip(self): 517 vals = [0.0, 1e-500, 1e-315, 1e-200, 0.0123, 3.1415, 1e50, INF, NAN] 518 vals += [-v for v in vals] 519 520 # complex(repr(z)) should recover z exactly, even for complex 521 # numbers involving an infinity, nan, or negative zero 522 for x in vals: 523 for y in vals: 524 z = complex(x, y) 525 roundtrip = complex(repr(z)) 526 self.assertFloatsAreIdentical(z.real, roundtrip.real) 527 self.assertFloatsAreIdentical(z.imag, roundtrip.imag) 528 529 # if we predefine some constants, then eval(repr(z)) should 530 # also work, except that it might change the sign of zeros 531 inf, nan = float('inf'), float('nan') 532 infj, nanj = complex(0.0, inf), complex(0.0, nan) 533 for x in vals: 534 for y in vals: 535 z = complex(x, y) 536 roundtrip = eval(repr(z)) 537 # adding 0.0 has no effect beside changing -0.0 to 0.0 538 self.assertFloatsAreIdentical(0.0 + z.real, 539 0.0 + roundtrip.real) 540 self.assertFloatsAreIdentical(0.0 + z.imag, 541 0.0 + roundtrip.imag) 542 543 def test_format(self): 544 # empty format string is same as str() 545 self.assertEqual(format(1+3j, ''), str(1+3j)) 546 self.assertEqual(format(1.5+3.5j, ''), str(1.5+3.5j)) 547 self.assertEqual(format(3j, ''), str(3j)) 548 self.assertEqual(format(3.2j, ''), str(3.2j)) 549 self.assertEqual(format(3+0j, ''), str(3+0j)) 550 self.assertEqual(format(3.2+0j, ''), str(3.2+0j)) 551 552 # empty presentation type should still be analogous to str, 553 # even when format string is nonempty (issue #5920). 554 self.assertEqual(format(3.2+0j, '-'), str(3.2+0j)) 555 self.assertEqual(format(3.2+0j, '<'), str(3.2+0j)) 556 z = 4/7. - 100j/7. 557 self.assertEqual(format(z, ''), str(z)) 558 self.assertEqual(format(z, '-'), str(z)) 559 self.assertEqual(format(z, '<'), str(z)) 560 self.assertEqual(format(z, '10'), str(z)) 561 z = complex(0.0, 3.0) 562 self.assertEqual(format(z, ''), str(z)) 563 self.assertEqual(format(z, '-'), str(z)) 564 self.assertEqual(format(z, '<'), str(z)) 565 self.assertEqual(format(z, '2'), str(z)) 566 z = complex(-0.0, 2.0) 567 self.assertEqual(format(z, ''), str(z)) 568 self.assertEqual(format(z, '-'), str(z)) 569 self.assertEqual(format(z, '<'), str(z)) 570 self.assertEqual(format(z, '3'), str(z)) 571 572 self.assertEqual(format(1+3j, 'g'), '1+3j') 573 self.assertEqual(format(3j, 'g'), '0+3j') 574 self.assertEqual(format(1.5+3.5j, 'g'), '1.5+3.5j') 575 576 self.assertEqual(format(1.5+3.5j, '+g'), '+1.5+3.5j') 577 self.assertEqual(format(1.5-3.5j, '+g'), '+1.5-3.5j') 578 self.assertEqual(format(1.5-3.5j, '-g'), '1.5-3.5j') 579 self.assertEqual(format(1.5+3.5j, ' g'), ' 1.5+3.5j') 580 self.assertEqual(format(1.5-3.5j, ' g'), ' 1.5-3.5j') 581 self.assertEqual(format(-1.5+3.5j, ' g'), '-1.5+3.5j') 582 self.assertEqual(format(-1.5-3.5j, ' g'), '-1.5-3.5j') 583 584 self.assertEqual(format(-1.5-3.5e-20j, 'g'), '-1.5-3.5e-20j') 585 self.assertEqual(format(-1.5-3.5j, 'f'), '-1.500000-3.500000j') 586 self.assertEqual(format(-1.5-3.5j, 'F'), '-1.500000-3.500000j') 587 self.assertEqual(format(-1.5-3.5j, 'e'), '-1.500000e+00-3.500000e+00j') 588 self.assertEqual(format(-1.5-3.5j, '.2e'), '-1.50e+00-3.50e+00j') 589 self.assertEqual(format(-1.5-3.5j, '.2E'), '-1.50E+00-3.50E+00j') 590 self.assertEqual(format(-1.5e10-3.5e5j, '.2G'), '-1.5E+10-3.5E+05j') 591 592 self.assertEqual(format(1.5+3j, '<20g'), '1.5+3j ') 593 self.assertEqual(format(1.5+3j, '*<20g'), '1.5+3j**************') 594 self.assertEqual(format(1.5+3j, '>20g'), ' 1.5+3j') 595 self.assertEqual(format(1.5+3j, '^20g'), ' 1.5+3j ') 596 self.assertEqual(format(1.5+3j, '<20'), '(1.5+3j) ') 597 self.assertEqual(format(1.5+3j, '>20'), ' (1.5+3j)') 598 self.assertEqual(format(1.5+3j, '^20'), ' (1.5+3j) ') 599 self.assertEqual(format(1.123-3.123j, '^20.2'), ' (1.1-3.1j) ') 600 601 self.assertEqual(format(1.5+3j, '20.2f'), ' 1.50+3.00j') 602 self.assertEqual(format(1.5+3j, '>20.2f'), ' 1.50+3.00j') 603 self.assertEqual(format(1.5+3j, '<20.2f'), '1.50+3.00j ') 604 self.assertEqual(format(1.5e20+3j, '<20.2f'), '150000000000000000000.00+3.00j') 605 self.assertEqual(format(1.5e20+3j, '>40.2f'), ' 150000000000000000000.00+3.00j') 606 self.assertEqual(format(1.5e20+3j, '^40,.2f'), ' 150,000,000,000,000,000,000.00+3.00j ') 607 self.assertEqual(format(1.5e21+3j, '^40,.2f'), ' 1,500,000,000,000,000,000,000.00+3.00j ') 608 self.assertEqual(format(1.5e21+3000j, ',.2f'), '1,500,000,000,000,000,000,000.00+3,000.00j') 609 610 # alternate is invalid 611 self.assertRaises(ValueError, (1.5+0.5j).__format__, '#f') 612 613 # zero padding is invalid 614 self.assertRaises(ValueError, (1.5+0.5j).__format__, '010f') 615 616 # '=' alignment is invalid 617 self.assertRaises(ValueError, (1.5+3j).__format__, '=20') 618 619 # integer presentation types are an error 620 for t in 'bcdoxX': 621 self.assertRaises(ValueError, (1.5+0.5j).__format__, t) 622 623 # make sure everything works in ''.format() 624 self.assertEqual('*{0:.3f}*'.format(3.14159+2.71828j), '*3.142+2.718j*') 625 626 # issue 3382: 'f' and 'F' with inf's and nan's 627 self.assertEqual('{0:f}'.format(INF+0j), 'inf+0.000000j') 628 self.assertEqual('{0:F}'.format(INF+0j), 'INF+0.000000j') 629 self.assertEqual('{0:f}'.format(-INF+0j), '-inf+0.000000j') 630 self.assertEqual('{0:F}'.format(-INF+0j), '-INF+0.000000j') 631 self.assertEqual('{0:f}'.format(complex(INF, INF)), 'inf+infj') 632 self.assertEqual('{0:F}'.format(complex(INF, INF)), 'INF+INFj') 633 self.assertEqual('{0:f}'.format(complex(INF, -INF)), 'inf-infj') 634 self.assertEqual('{0:F}'.format(complex(INF, -INF)), 'INF-INFj') 635 self.assertEqual('{0:f}'.format(complex(-INF, INF)), '-inf+infj') 636 self.assertEqual('{0:F}'.format(complex(-INF, INF)), '-INF+INFj') 637 self.assertEqual('{0:f}'.format(complex(-INF, -INF)), '-inf-infj') 638 self.assertEqual('{0:F}'.format(complex(-INF, -INF)), '-INF-INFj') 639 640 self.assertEqual('{0:f}'.format(complex(NAN, 0)), 'nan+0.000000j') 641 self.assertEqual('{0:F}'.format(complex(NAN, 0)), 'NAN+0.000000j') 642 self.assertEqual('{0:f}'.format(complex(NAN, NAN)), 'nan+nanj') 643 self.assertEqual('{0:F}'.format(complex(NAN, NAN)), 'NAN+NANj') 393 644 394 645 def test_main(): 395 test_support.run_unittest(ComplexTest) 646 with test_support.check_warnings(("complex divmod.., // and % are " 647 "deprecated", DeprecationWarning)): 648 test_support.run_unittest(ComplexTest) 396 649 397 650 if __name__ == "__main__":
Note:
See TracChangeset
for help on using the changeset viewer.
