| 1 |
import unittest |
| 2 |
import sys |
| 3 |
from test import support |
| 4 |
from test.support.testcase import ComplexesAreIdenticalMixin |
| 5 |
from test.support.numbers import ( |
| 6 |
VALID_UNDERSCORE_LITERALS, |
| 7 |
INVALID_UNDERSCORE_LITERALS, |
| 8 |
) |
| 9 |
|
| 10 |
from random import random |
| 11 |
from math import isnan, copysign |
| 12 |
import operator |
| 13 |
|
| 14 |
INF = float("inf") |
| 15 |
NAN = float("nan") |
| 16 |
DBL_MAX = sys.float_info.max |
| 17 |
# These tests ensure that complex math does the right thing |
| 18 |
|
| 19 |
ZERO_DIVISION = ( |
| 20 |
(1+1j, 0+0j), |
| 21 |
(1+1j, 0.0), |
| 22 |
(1+1j, 0), |
| 23 |
(1.0, 0+0j), |
| 24 |
(1, 0+0j), |
| 25 |
) |
| 26 |
|
| 27 |
class WithIndex: |
| 28 |
def __init__(self, value): |
| 29 |
self.value = value |
| 30 |
def __index__(self): |
| 31 |
return self.value |
| 32 |
|
| 33 |
class WithFloat: |
| 34 |
def __init__(self, value): |
| 35 |
self.value = value |
| 36 |
def __float__(self): |
| 37 |
return self.value |
| 38 |
|
| 39 |
class ComplexSubclass(complex): |
| 40 |
pass |
| 41 |
|
| 42 |
class OtherComplexSubclass(complex): |
| 43 |
pass |
| 44 |
|
| 45 |
class MyInt: |
| 46 |
def __init__(self, value): |
| 47 |
self.value = value |
| 48 |
|
| 49 |
def __int__(self): |
| 50 |
return self.value |
| 51 |
|
| 52 |
class WithComplex: |
| 53 |
def __init__(self, value): |
| 54 |
self.value = value |
| 55 |
def __complex__(self): |
| 56 |
return self.value |
| 57 |
|
| 58 |
class ComplexTest(ComplexesAreIdenticalMixin, unittest.TestCase): |
| 59 |
|
| 60 |
def assertAlmostEqual(self, a, b): |
| 61 |
if isinstance(a, complex): |
| 62 |
if isinstance(b, complex): |
| 63 |
unittest.TestCase.assertAlmostEqual(self, a.real, b.real) |
| 64 |
unittest.TestCase.assertAlmostEqual(self, a.imag, b.imag) |
| 65 |
else: |
| 66 |
unittest.TestCase.assertAlmostEqual(self, a.real, b) |
| 67 |
unittest.TestCase.assertAlmostEqual(self, a.imag, 0.) |
| 68 |
else: |
| 69 |
if isinstance(b, complex): |
| 70 |
unittest.TestCase.assertAlmostEqual(self, a, b.real) |
| 71 |
unittest.TestCase.assertAlmostEqual(self, 0., b.imag) |
| 72 |
else: |
| 73 |
unittest.TestCase.assertAlmostEqual(self, a, b) |
| 74 |
|
| 75 |
def assertClose(self, x, y, eps=1e-9): |
| 76 |
"""Return true iff complexes x and y "are close".""" |
| 77 |
# put the one with larger magnitude second |
| 78 |
if abs(x) > abs(y): |
| 79 |
x, y = y, x |
| 80 |
if y == 0: |
| 81 |
return abs(x) < eps |
| 82 |
if x == 0: |
| 83 |
return abs(y) < eps |
| 84 |
# check that relative difference < eps |
| 85 |
self.assertTrue(abs(x-y)/abs(y) < eps) |
| 86 |
|
| 87 |
def check_div(self, x, y): |
| 88 |
"""Compute complex z=x*y, and check that z/x==y and z/y==x.""" |
| 89 |
z = x * y |
| 90 |
if x: |
| 91 |
self.assertClose(z / x, y) |
| 92 |
if y: |
| 93 |
self.assertClose(z / y, x) |
| 94 |
|
| 95 |
def test_truediv(self): |
| 96 |
simple_real = [float(i) for i in range(-5, 6)] |
| 97 |
simple_complex = [complex(x, y) for x in simple_real for y in simple_real] |
| 98 |
for x in simple_complex: |
| 99 |
for y in simple_complex: |
| 100 |
self.check_div(x, y) |
| 101 |
|
| 102 |
# A naive complex division algorithm (such as in 2.0) is very prone to |
| 103 |
# nonsense errors for these (overflows and underflows). |
| 104 |
self.check_div(complex(1e200, 1e200), 1+0j) |
| 105 |
self.check_div(complex(1e-200, 1e-200), 1+0j) |
| 106 |
|
| 107 |
# Smith's algorithm has several sources of inaccuracy |
| 108 |
# for components of the result. In examples below, |
| 109 |
# it's cancellation of digits in computation of sum. |
| 110 |
self.check_div(1e-09+1j, 1+1j) |
| 111 |
self.check_div(8.289760544677449e-09+0.13257307440728516j, |
| 112 |
0.9059966714925808+0.5054864708672686j) |
| 113 |
|
| 114 |
# Just for fun. |
| 115 |
for i in range(100): |
| 116 |
x = complex(random(), random()) |
| 117 |
y = complex(random(), random()) |
| 118 |
self.check_div(x, y) |
| 119 |
y = complex(1e10*y.real, y.imag) |
| 120 |
self.check_div(x, y) |
| 121 |
|
| 122 |
self.assertAlmostEqual(complex.__truediv__(2+0j, 1+1j), 1-1j) |
| 123 |
self.assertRaises(TypeError, operator.truediv, 1j, None) |
| 124 |
self.assertRaises(TypeError, operator.truediv, None, 1j) |
| 125 |
|
| 126 |
for denom_real, denom_imag in [(0, NAN), (NAN, 0), (NAN, NAN)]: |
| 127 |
z = complex(0, 0) / complex(denom_real, denom_imag) |
| 128 |
self.assertTrue(isnan(z.real)) |
| 129 |
self.assertTrue(isnan(z.imag)) |
| 130 |
z = float(0) / complex(denom_real, denom_imag) |
| 131 |
self.assertTrue(isnan(z.real)) |
| 132 |
self.assertTrue(isnan(z.imag)) |
| 133 |
|
| 134 |
self.assertComplexesAreIdentical(complex(INF, NAN) / 2, |
| 135 |
complex(INF, NAN)) |
| 136 |
|
| 137 |
self.assertComplexesAreIdentical(complex(INF, 1)/(0.0+1j), |
| 138 |
complex(NAN, -INF)) |
| 139 |
|
| 140 |
# test recover of infs if numerator has infs and denominator is finite |
| 141 |
self.assertComplexesAreIdentical(complex(INF, -INF)/(1+0j), |
| 142 |
complex(INF, -INF)) |
| 143 |
self.assertComplexesAreIdentical(complex(INF, INF)/(0.0+1j), |
| 144 |
complex(INF, -INF)) |
| 145 |
self.assertComplexesAreIdentical(complex(NAN, INF)/complex(2**1000, 2**-1000), |
| 146 |
complex(INF, INF)) |
| 147 |
self.assertComplexesAreIdentical(complex(INF, NAN)/complex(2**1000, 2**-1000), |
| 148 |
complex(INF, -INF)) |
| 149 |
|
| 150 |
# test recover of zeros if denominator is infinite |
| 151 |
self.assertComplexesAreIdentical((1+1j)/complex(INF, INF), (0.0+0j)) |
| 152 |
self.assertComplexesAreIdentical((1+1j)/complex(INF, -INF), (0.0+0j)) |
| 153 |
self.assertComplexesAreIdentical((1+1j)/complex(-INF, INF), |
| 154 |
complex(0.0, -0.0)) |
| 155 |
self.assertComplexesAreIdentical((1+1j)/complex(-INF, -INF), |
| 156 |
complex(-0.0, 0)) |
| 157 |
self.assertComplexesAreIdentical((INF+1j)/complex(INF, INF), |
| 158 |
complex(NAN, NAN)) |
| 159 |
self.assertComplexesAreIdentical(complex(1, INF)/complex(INF, INF), |
| 160 |
complex(NAN, NAN)) |
| 161 |
self.assertComplexesAreIdentical(complex(INF, 1)/complex(1, INF), |
| 162 |
complex(NAN, NAN)) |
| 163 |
|
| 164 |
# mixed types |
| 165 |
self.assertEqual((1+1j)/float(2), 0.5+0.5j) |
| 166 |
self.assertEqual(float(1)/(1+2j), 0.2-0.4j) |
| 167 |
self.assertEqual(float(1)/(-1+2j), -0.2-0.4j) |
| 168 |
self.assertEqual(float(1)/(1-2j), 0.2+0.4j) |
| 169 |
self.assertEqual(float(1)/(2+1j), 0.4-0.2j) |
| 170 |
self.assertEqual(float(1)/(-2+1j), -0.4-0.2j) |
| 171 |
self.assertEqual(float(1)/(2-1j), 0.4+0.2j) |
| 172 |
|
| 173 |
self.assertComplexesAreIdentical(INF/(1+0j), |
| 174 |
complex(INF, NAN)) |
| 175 |
self.assertComplexesAreIdentical(INF/(0.0+1j), |
| 176 |
complex(NAN, -INF)) |
| 177 |
self.assertComplexesAreIdentical(INF/complex(2**1000, 2**-1000), |
| 178 |
complex(INF, NAN)) |
| 179 |
self.assertComplexesAreIdentical(INF/complex(NAN, NAN), |
| 180 |
complex(NAN, NAN)) |
| 181 |
|
| 182 |
self.assertComplexesAreIdentical(float(1)/complex(INF, INF), (0.0-0j)) |
| 183 |
self.assertComplexesAreIdentical(float(1)/complex(INF, -INF), (0.0+0j)) |
| 184 |
self.assertComplexesAreIdentical(float(1)/complex(-INF, INF), |
| 185 |
complex(-0.0, -0.0)) |
| 186 |
self.assertComplexesAreIdentical(float(1)/complex(-INF, -INF), |
| 187 |
complex(-0.0, 0)) |
| 188 |
self.assertComplexesAreIdentical(float(1)/complex(INF, NAN), |
| 189 |
complex(0.0, -0.0)) |
| 190 |
self.assertComplexesAreIdentical(float(1)/complex(-INF, NAN), |
| 191 |
complex(-0.0, -0.0)) |
| 192 |
self.assertComplexesAreIdentical(float(1)/complex(NAN, INF), |
| 193 |
complex(0.0, -0.0)) |
| 194 |
self.assertComplexesAreIdentical(float(INF)/complex(NAN, INF), |
| 195 |
complex(NAN, NAN)) |
| 196 |
|
| 197 |
def test_truediv_zero_division(self): |
| 198 |
for a, b in ZERO_DIVISION: |
| 199 |
with self.assertRaises(ZeroDivisionError): |
| 200 |
a / b |
| 201 |
|
| 202 |
def test_floordiv(self): |
| 203 |
with self.assertRaises(TypeError): |
| 204 |
(1+1j) // (1+0j) |
| 205 |
with self.assertRaises(TypeError): |
| 206 |
(1+1j) // 1.0 |
| 207 |
with self.assertRaises(TypeError): |
| 208 |
(1+1j) // 1 |
| 209 |
with self.assertRaises(TypeError): |
| 210 |
1.0 // (1+0j) |
| 211 |
with self.assertRaises(TypeError): |
| 212 |
1 // (1+0j) |
| 213 |
|
| 214 |
def test_floordiv_zero_division(self): |
| 215 |
for a, b in ZERO_DIVISION: |
| 216 |
with self.assertRaises(TypeError): |
| 217 |
a // b |
| 218 |
|
| 219 |
def test_richcompare(self): |
| 220 |
self.assertIs(complex.__eq__(1+1j, 1<<10000), False) |
| 221 |
self.assertIs(complex.__lt__(1+1j, None), NotImplemented) |
| 222 |
self.assertIs(complex.__eq__(1+1j, None), NotImplemented) |
| 223 |
self.assertIs(complex.__eq__(1+1j, 1+1j), True) |
| 224 |
self.assertIs(complex.__eq__(1+1j, 2+2j), False) |
| 225 |
self.assertIs(complex.__ne__(1+1j, 1+1j), False) |
| 226 |
self.assertIs(complex.__ne__(1+1j, 2+2j), True) |
| 227 |
for i in range(1, 100): |
| 228 |
f = i / 100.0 |
| 229 |
self.assertIs(complex.__eq__(f+0j, f), True) |
| 230 |
self.assertIs(complex.__ne__(f+0j, f), False) |
| 231 |
self.assertIs(complex.__eq__(complex(f, f), f), False) |
| 232 |
self.assertIs(complex.__ne__(complex(f, f), f), True) |
| 233 |
self.assertIs(complex.__lt__(1+1j, 2+2j), NotImplemented) |
| 234 |
self.assertIs(complex.__le__(1+1j, 2+2j), NotImplemented) |
| 235 |
self.assertIs(complex.__gt__(1+1j, 2+2j), NotImplemented) |
| 236 |
self.assertIs(complex.__ge__(1+1j, 2+2j), NotImplemented) |
| 237 |
self.assertRaises(TypeError, operator.lt, 1+1j, 2+2j) |
| 238 |
self.assertRaises(TypeError, operator.le, 1+1j, 2+2j) |
| 239 |
self.assertRaises(TypeError, operator.gt, 1+1j, 2+2j) |
| 240 |
self.assertRaises(TypeError, operator.ge, 1+1j, 2+2j) |
| 241 |
self.assertIs(operator.eq(1+1j, 1+1j), True) |
| 242 |
self.assertIs(operator.eq(1+1j, 2+2j), False) |
| 243 |
self.assertIs(operator.ne(1+1j, 1+1j), False) |
| 244 |
self.assertIs(operator.ne(1+1j, 2+2j), True) |
| 245 |
self.assertIs(operator.eq(1+1j, 2.0), False) |
| 246 |
|
| 247 |
def test_richcompare_boundaries(self): |
| 248 |
def check(n, deltas, is_equal, imag = 0.0): |
| 249 |
for delta in deltas: |
| 250 |
i = n + delta |
| 251 |
z = complex(i, imag) |
| 252 |
self.assertIs(complex.__eq__(z, i), is_equal(delta)) |
| 253 |
self.assertIs(complex.__ne__(z, i), not is_equal(delta)) |
| 254 |
# For IEEE-754 doubles the following should hold: |
| 255 |
# x in [2 ** (52 + i), 2 ** (53 + i + 1)] -> x mod 2 ** i == 0 |
| 256 |
# where the interval is representable, of course. |
| 257 |
for i in range(1, 10): |
| 258 |
pow = 52 + i |
| 259 |
mult = 2 ** i |
| 260 |
check(2 ** pow, range(1, 101), lambda delta: delta % mult == 0) |
| 261 |
check(2 ** pow, range(1, 101), lambda delta: False, float(i)) |
| 262 |
check(2 ** 53, range(-100, 0), lambda delta: True) |
| 263 |
|
| 264 |
def test_add(self): |
| 265 |
self.assertEqual(1j + int(+1), complex(+1, 1)) |
| 266 |
self.assertEqual(1j + int(-1), complex(-1, 1)) |
| 267 |
self.assertComplexesAreIdentical(complex(-0.0, -0.0) + (-0.0), |
| 268 |
complex(-0.0, -0.0)) |
| 269 |
self.assertComplexesAreIdentical((-0.0) + complex(-0.0, -0.0), |
| 270 |
complex(-0.0, -0.0)) |
| 271 |
self.assertRaises(OverflowError, operator.add, 1j, 10**1000) |
| 272 |
self.assertRaises(TypeError, operator.add, 1j, None) |
| 273 |
self.assertRaises(TypeError, operator.add, None, 1j) |
| 274 |
|
| 275 |
def test_sub(self): |
| 276 |
self.assertEqual(1j - int(+1), complex(-1, 1)) |
| 277 |
self.assertEqual(1j - int(-1), complex(1, 1)) |
| 278 |
self.assertComplexesAreIdentical(complex(-0.0, -0.0) - 0.0, |
| 279 |
complex(-0.0, -0.0)) |
| 280 |
self.assertComplexesAreIdentical(-0.0 - complex(0.0, 0.0), |
| 281 |
complex(-0.0, -0.0)) |
| 282 |
self.assertComplexesAreIdentical(complex(1, 2) - complex(2, 1), |
| 283 |
complex(-1, 1)) |
| 284 |
self.assertComplexesAreIdentical(complex(2, 1) - complex(1, 2), |
| 285 |
complex(1, -1)) |
| 286 |
self.assertRaises(OverflowError, operator.sub, 1j, 10**1000) |
| 287 |
self.assertRaises(TypeError, operator.sub, 1j, None) |
| 288 |
self.assertRaises(TypeError, operator.sub, None, 1j) |
| 289 |
|
| 290 |
def test_mul(self): |
| 291 |
self.assertEqual(1j * int(20), complex(0, 20)) |
| 292 |
self.assertEqual(1j * int(-1), complex(0, -1)) |
| 293 |
for c, r in [(2, complex(INF, 2)), (INF, complex(INF, INF)), |
| 294 |
(0, complex(NAN, 0)), (-0.0, complex(NAN, -0.0)), |
| 295 |
(NAN, complex(NAN, NAN))]: |
| 296 |
with self.subTest(c=c, r=r): |
| 297 |
self.assertComplexesAreIdentical(complex(INF, 1) * c, r) |
| 298 |
self.assertComplexesAreIdentical(c * complex(INF, 1), r) |
| 299 |
self.assertRaises(OverflowError, operator.mul, 1j, 10**1000) |
| 300 |
self.assertRaises(TypeError, operator.mul, 1j, None) |
| 301 |
self.assertRaises(TypeError, operator.mul, None, 1j) |
| 302 |
|
| 303 |
for z, w, r in [(1e300+1j, complex(INF, INF), complex(NAN, INF)), |
| 304 |
(1e300+1j, complex(NAN, INF), complex(-INF, INF)), |
| 305 |
(1e300+1j, complex(INF, NAN), complex(INF, INF)), |
| 306 |
(complex(INF, 1), complex(NAN, INF), complex(NAN, INF)), |
| 307 |
(complex(INF, 1), complex(INF, NAN), complex(INF, NAN)), |
| 308 |
(complex(NAN, 1), complex(1, INF), complex(-INF, NAN)), |
| 309 |
(complex(1, NAN), complex(1, INF), complex(NAN, INF)), |
| 310 |
(complex(1e200, NAN), complex(1e200, NAN), complex(INF, NAN)), |
| 311 |
(complex(1e200, NAN), complex(NAN, 1e200), complex(NAN, INF)), |
| 312 |
(complex(NAN, 1e200), complex(1e200, NAN), complex(NAN, INF)), |
| 313 |
(complex(NAN, 1e200), complex(NAN, 1e200), complex(-INF, NAN)), |
| 314 |
(complex(NAN, NAN), complex(NAN, NAN), complex(NAN, NAN))]: |
| 315 |
with self.subTest(z=z, w=w, r=r): |
| 316 |
self.assertComplexesAreIdentical(z * w, r) |
| 317 |
self.assertComplexesAreIdentical(w * z, r) |
| 318 |
|
| 319 |
def test_mod(self): |
| 320 |
# % is no longer supported on complex numbers |
| 321 |
with self.assertRaises(TypeError): |
| 322 |
(1+1j) % (1+0j) |
| 323 |
with self.assertRaises(TypeError): |
| 324 |
(1+1j) % 1.0 |
| 325 |
with self.assertRaises(TypeError): |
| 326 |
(1+1j) % 1 |
| 327 |
with self.assertRaises(TypeError): |
| 328 |
1.0 % (1+0j) |
| 329 |
with self.assertRaises(TypeError): |
| 330 |
1 % (1+0j) |
| 331 |
|
| 332 |
def test_mod_zero_division(self): |
| 333 |
for a, b in ZERO_DIVISION: |
| 334 |
with self.assertRaises(TypeError): |
| 335 |
a % b |
| 336 |
|
| 337 |
def test_divmod(self): |
| 338 |
self.assertRaises(TypeError, divmod, 1+1j, 1+0j) |
| 339 |
self.assertRaises(TypeError, divmod, 1+1j, 1.0) |
| 340 |
self.assertRaises(TypeError, divmod, 1+1j, 1) |
| 341 |
self.assertRaises(TypeError, divmod, 1.0, 1+0j) |
| 342 |
self.assertRaises(TypeError, divmod, 1, 1+0j) |
| 343 |
|
| 344 |
def test_divmod_zero_division(self): |
| 345 |
for a, b in ZERO_DIVISION: |
| 346 |
self.assertRaises(TypeError, divmod, a, b) |
| 347 |
|
| 348 |
def test_pow(self): |
| 349 |
self.assertAlmostEqual(pow(1+1j, 0+0j), 1.0) |
| 350 |
self.assertAlmostEqual(pow(0+0j, 2+0j), 0.0) |
| 351 |
self.assertEqual(pow(0+0j, 2000+0j), 0.0) |
| 352 |
self.assertEqual(pow(0, 0+0j), 1.0) |
| 353 |
self.assertEqual(pow(-1, 0+0j), 1.0) |
| 354 |
self.assertRaises(ZeroDivisionError, pow, 0+0j, 1j) |
| 355 |
self.assertRaises(ZeroDivisionError, pow, 0+0j, -1000) |
| 356 |
self.assertAlmostEqual(pow(1j, -1), 1/1j) |
| 357 |
self.assertAlmostEqual(pow(1j, 200), 1) |
| 358 |
self.assertRaises(ValueError, pow, 1+1j, 1+1j, 1+1j) |
| 359 |
self.assertRaises(OverflowError, pow, 1e200+1j, 1e200+1j) |
| 360 |
self.assertRaises(OverflowError, pow, 1e200+1j, 5) |
| 361 |
self.assertRaises(TypeError, pow, 1j, None) |
| 362 |
self.assertRaises(TypeError, pow, None, 1j) |
| 363 |
self.assertAlmostEqual(pow(1j, 0.5), 0.7071067811865476+0.7071067811865475j) |
| 364 |
|
| 365 |
a = 3.33+4.43j |
| 366 |
self.assertEqual(a ** 0j, 1) |
| 367 |
self.assertEqual(a ** 0.+0.j, 1) |
| 368 |
|
| 369 |
self.assertEqual(3j ** 0j, 1) |
| 370 |
self.assertEqual(3j ** 0, 1) |
| 371 |
|
| 372 |
try: |
| 373 |
0j ** a |
| 374 |
except ZeroDivisionError: |
| 375 |
pass |
| 376 |
else: |
| 377 |
self.fail("should fail 0.0 to negative or complex power") |
| 378 |
|
| 379 |
try: |
| 380 |
0j ** (3-2j) |
| 381 |
except ZeroDivisionError: |
| 382 |
pass |
| 383 |
else: |
| 384 |
self.fail("should fail 0.0 to negative or complex power") |
| 385 |
|
| 386 |
# The following is used to exercise certain code paths |
| 387 |
self.assertEqual(a ** 105, a ** 105) |
| 388 |
self.assertEqual(a ** -105, a ** -105) |
| 389 |
self.assertEqual(a ** -30, a ** -30) |
| 390 |
|
| 391 |
self.assertEqual(0.0j ** 0, 1) |
| 392 |
|
| 393 |
b = 5.1+2.3j |
| 394 |
self.assertRaises(ValueError, pow, a, b, 0) |
| 395 |
|
| 396 |
# Check some boundary conditions; some of these used to invoke |
| 397 |
# undefined behaviour (https://bugs.python.org/issue44698). We're |
| 398 |
# not actually checking the results of these operations, just making |
| 399 |
# sure they don't crash (for example when using clang's |
| 400 |
# UndefinedBehaviourSanitizer). |
| 401 |
values = (sys.maxsize, sys.maxsize+1, sys.maxsize-1, |
| 402 |
-sys.maxsize, -sys.maxsize+1, -sys.maxsize+1) |
| 403 |
for real in values: |
| 404 |
for imag in values: |
| 405 |
with self.subTest(real=real, imag=imag): |
| 406 |
c = complex(real, imag) |
| 407 |
try: |
| 408 |
c ** real |
| 409 |
except OverflowError: |
| 410 |
pass |
| 411 |
try: |
| 412 |
c ** c |
| 413 |
except OverflowError: |
| 414 |
pass |
| 415 |
|
| 416 |
# gh-113841: possible undefined division by 0 in _Py_c_pow() |
| 417 |
x, y = 9j, 33j**3 |
| 418 |
with self.assertRaises(OverflowError): |
| 419 |
x**y |
| 420 |
|
| 421 |
def test_pow_with_small_integer_exponents(self): |
| 422 |
# Check that small integer exponents are handled identically |
| 423 |
# regardless of their type. |
| 424 |
values = [ |
| 425 |
complex(5.0, 12.0), |
| 426 |
complex(5.0e100, 12.0e100), |
| 427 |
complex(-4.0, INF), |
| 428 |
complex(INF, 0.0), |
| 429 |
] |
| 430 |
exponents = [-19, -5, -3, -2, -1, 0, 1, 2, 3, 5, 19] |
| 431 |
for value in values: |
| 432 |
for exponent in exponents: |
| 433 |
with self.subTest(value=value, exponent=exponent): |
| 434 |
try: |
| 435 |
int_pow = value**exponent |
| 436 |
except OverflowError: |
| 437 |
int_pow = "overflow" |
| 438 |
try: |
| 439 |
float_pow = value**float(exponent) |
| 440 |
except OverflowError: |
| 441 |
float_pow = "overflow" |
| 442 |
try: |
| 443 |
complex_pow = value**complex(exponent) |
| 444 |
except OverflowError: |
| 445 |
complex_pow = "overflow" |
| 446 |
self.assertEqual(str(float_pow), str(int_pow)) |
| 447 |
self.assertEqual(str(complex_pow), str(int_pow)) |
| 448 |
|
| 449 |
def test_boolcontext(self): |
| 450 |
for i in range(100): |
| 451 |
self.assertTrue(complex(random() + 1e-6, random() + 1e-6)) |
| 452 |
self.assertTrue(not complex(0.0, 0.0)) |
| 453 |
self.assertTrue(1j) |
| 454 |
|
| 455 |
def test_conjugate(self): |
| 456 |
self.assertEqual(complex(5.3, 9.8).conjugate(), 5.3-9.8j) |
| 457 |
|
| 458 |
def test_constructor(self): |
| 459 |
def check(z, x, y): |
| 460 |
self.assertIs(type(z), complex) |
| 461 |
self.assertFloatsAreIdentical(z.real, x) |
| 462 |
self.assertFloatsAreIdentical(z.imag, y) |
| 463 |
|
| 464 |
check(complex(), 0.0, 0.0) |
| 465 |
check(complex(10), 10.0, 0.0) |
| 466 |
check(complex(4.25), 4.25, 0.0) |
| 467 |
check(complex(4.25+0j), 4.25, 0.0) |
| 468 |
check(complex(4.25+0.5j), 4.25, 0.5) |
| 469 |
check(complex(ComplexSubclass(4.25+0.5j)), 4.25, 0.5) |
| 470 |
check(complex(WithComplex(4.25+0.5j)), 4.25, 0.5) |
| 471 |
|
| 472 |
check(complex(1, 10), 1.0, 10.0) |
| 473 |
check(complex(1, 10.0), 1.0, 10.0) |
| 474 |
check(complex(1, 4.25), 1.0, 4.25) |
| 475 |
check(complex(1.0, 10), 1.0, 10.0) |
| 476 |
check(complex(4.25, 10), 4.25, 10.0) |
| 477 |
check(complex(1.0, 10.0), 1.0, 10.0) |
| 478 |
check(complex(4.25, 0.5), 4.25, 0.5) |
| 479 |
|
| 480 |
with self.assertWarnsRegex(DeprecationWarning, |
| 481 |
"argument 'real' must be a real number, not complex"): |
| 482 |
check(complex(4.25+0j, 0), 4.25, 0.0) |
| 483 |
with self.assertWarnsRegex(DeprecationWarning, |
| 484 |
"argument 'real' must be a real number, not .*ComplexSubclass"): |
| 485 |
check(complex(ComplexSubclass(4.25+0j), 0), 4.25, 0.0) |
| 486 |
with self.assertWarnsRegex(DeprecationWarning, |
| 487 |
"argument 'real' must be a real number, not .*WithComplex"): |
| 488 |
check(complex(WithComplex(4.25+0j), 0), 4.25, 0.0) |
| 489 |
with self.assertWarnsRegex(DeprecationWarning, |
| 490 |
"argument 'real' must be a real number, not complex"): |
| 491 |
check(complex(4.25j, 0), 0.0, 4.25) |
| 492 |
with self.assertWarnsRegex(DeprecationWarning, |
| 493 |
"argument 'real' must be a real number, not complex"): |
| 494 |
check(complex(0j, 4.25), 0.0, 4.25) |
| 495 |
with self.assertWarnsRegex(DeprecationWarning, |
| 496 |
"argument 'imag' must be a real number, not complex"): |
| 497 |
check(complex(0, 4.25+0j), 0.0, 4.25) |
| 498 |
with self.assertWarnsRegex(DeprecationWarning, |
| 499 |
"argument 'imag' must be a real number, not .*ComplexSubclass"): |
| 500 |
check(complex(0, ComplexSubclass(4.25+0j)), 0.0, 4.25) |
| 501 |
with self.assertRaisesRegex(TypeError, |
| 502 |
"argument 'imag' must be a real number, not .*WithComplex"): |
| 503 |
complex(0, WithComplex(4.25+0j)) |
| 504 |
with self.assertWarnsRegex(DeprecationWarning, |
| 505 |
"argument 'imag' must be a real number, not complex"): |
| 506 |
check(complex(0.0, 4.25j), -4.25, 0.0) |
| 507 |
with self.assertWarnsRegex(DeprecationWarning, |
| 508 |
"argument 'real' must be a real number, not complex"): |
| 509 |
check(complex(4.25+0j, 0j), 4.25, 0.0) |
| 510 |
with self.assertWarnsRegex(DeprecationWarning, |
| 511 |
"argument 'real' must be a real number, not complex"): |
| 512 |
check(complex(4.25j, 0j), 0.0, 4.25) |
| 513 |
with self.assertWarnsRegex(DeprecationWarning, |
| 514 |
"argument 'real' must be a real number, not complex"): |
| 515 |
check(complex(0j, 4.25+0j), 0.0, 4.25) |
| 516 |
with self.assertWarnsRegex(DeprecationWarning, |
| 517 |
"argument 'real' must be a real number, not complex"): |
| 518 |
check(complex(0j, 4.25j), -4.25, 0.0) |
| 519 |
|
| 520 |
check(complex(real=4.25), 4.25, 0.0) |
| 521 |
with self.assertWarnsRegex(DeprecationWarning, |
| 522 |
"argument 'real' must be a real number, not complex"): |
| 523 |
check(complex(real=4.25+0j), 4.25, 0.0) |
| 524 |
with self.assertWarnsRegex(DeprecationWarning, |
| 525 |
"argument 'real' must be a real number, not complex"): |
| 526 |
check(complex(real=4.25+1.5j), 4.25, 1.5) |
| 527 |
check(complex(imag=1.5), 0.0, 1.5) |
| 528 |
check(complex(real=4.25, imag=1.5), 4.25, 1.5) |
| 529 |
check(complex(4.25, imag=1.5), 4.25, 1.5) |
| 530 |
|
| 531 |
# check that the sign of a zero in the real or imaginary part |
| 532 |
# is preserved when constructing from two floats. |
| 533 |
for x in 1.0, -1.0: |
| 534 |
for y in 0.0, -0.0: |
| 535 |
check(complex(x, y), x, y) |
| 536 |
check(complex(y, x), y, x) |
| 537 |
|
| 538 |
c = complex(4.25, 1.5) |
| 539 |
self.assertIs(complex(c), c) |
| 540 |
c2 = ComplexSubclass(c) |
| 541 |
self.assertEqual(c2, c) |
| 542 |
self.assertIs(type(c2), ComplexSubclass) |
| 543 |
del c, c2 |
| 544 |
|
| 545 |
self.assertRaisesRegex(TypeError, |
| 546 |
"argument must be a string or a number, not dict", |
| 547 |
complex, {}) |
| 548 |
self.assertRaisesRegex(TypeError, |
| 549 |
"argument must be a string or a number, not NoneType", |
| 550 |
complex, None) |
| 551 |
self.assertRaisesRegex(TypeError, |
| 552 |
"argument 'real' must be a real number, not dict", |
| 553 |
complex, {1:2}, 0) |
| 554 |
self.assertRaisesRegex(TypeError, |
| 555 |
"argument 'real' must be a real number, not str", |
| 556 |
complex, '1', 0) |
| 557 |
self.assertRaisesRegex(TypeError, |
| 558 |
"argument 'imag' must be a real number, not dict", |
| 559 |
complex, 0, {1:2}) |
| 560 |
self.assertRaisesRegex(TypeError, |
| 561 |
"argument 'imag' must be a real number, not str", |
| 562 |
complex, 0, '1') |
| 563 |
|
| 564 |
self.assertRaises(TypeError, complex, WithComplex(1.5)) |
| 565 |
self.assertRaises(TypeError, complex, WithComplex(1)) |
| 566 |
self.assertRaises(TypeError, complex, WithComplex(None)) |
| 567 |
self.assertRaises(TypeError, complex, WithComplex(4.25+0j), object()) |
| 568 |
self.assertRaises(TypeError, complex, WithComplex(1.5), object()) |
| 569 |
self.assertRaises(TypeError, complex, WithComplex(1), object()) |
| 570 |
self.assertRaises(TypeError, complex, WithComplex(None), object()) |
| 571 |
|
| 572 |
class EvilExc(Exception): |
| 573 |
pass |
| 574 |
|
| 575 |
class evilcomplex: |
| 576 |
def __complex__(self): |
| 577 |
raise EvilExc |
| 578 |
|
| 579 |
self.assertRaises(EvilExc, complex, evilcomplex()) |
| 580 |
|
| 581 |
check(complex(WithFloat(4.25)), 4.25, 0.0) |
| 582 |
check(complex(WithFloat(4.25), 1.5), 4.25, 1.5) |
| 583 |
check(complex(1.5, WithFloat(4.25)), 1.5, 4.25) |
| 584 |
self.assertRaises(TypeError, complex, WithFloat(42)) |
| 585 |
self.assertRaises(TypeError, complex, WithFloat(42), 1.5) |
| 586 |
self.assertRaises(TypeError, complex, 1.5, WithFloat(42)) |
| 587 |
self.assertRaises(TypeError, complex, WithFloat(None)) |
| 588 |
self.assertRaises(TypeError, complex, WithFloat(None), 1.5) |
| 589 |
self.assertRaises(TypeError, complex, 1.5, WithFloat(None)) |
| 590 |
|
| 591 |
check(complex(WithIndex(42)), 42.0, 0.0) |
| 592 |
check(complex(WithIndex(42), 1.5), 42.0, 1.5) |
| 593 |
check(complex(1.5, WithIndex(42)), 1.5, 42.0) |
| 594 |
self.assertRaises(OverflowError, complex, WithIndex(2**2000)) |
| 595 |
self.assertRaises(OverflowError, complex, WithIndex(2**2000), 1.5) |
| 596 |
self.assertRaises(OverflowError, complex, 1.5, WithIndex(2**2000)) |
| 597 |
self.assertRaises(TypeError, complex, WithIndex(None)) |
| 598 |
self.assertRaises(TypeError, complex, WithIndex(None), 1.5) |
| 599 |
self.assertRaises(TypeError, complex, 1.5, WithIndex(None)) |
| 600 |
|
| 601 |
class MyInt: |
| 602 |
def __int__(self): |
| 603 |
return 42 |
| 604 |
|
| 605 |
self.assertRaises(TypeError, complex, MyInt()) |
| 606 |
self.assertRaises(TypeError, complex, MyInt(), 1.5) |
| 607 |
self.assertRaises(TypeError, complex, 1.5, MyInt()) |
| 608 |
|
| 609 |
class complex0(complex): |
| 610 |
"""Test usage of __complex__() when inheriting from 'complex'""" |
| 611 |
def __complex__(self): |
| 612 |
return 42j |
| 613 |
|
| 614 |
class complex1(complex): |
| 615 |
"""Test usage of __complex__() with a __new__() method""" |
| 616 |
def __new__(self, value=0j): |
| 617 |
return complex.__new__(self, 2*value) |
| 618 |
def __complex__(self): |
| 619 |
return self |
| 620 |
|
| 621 |
class complex2(complex): |
| 622 |
"""Make sure that __complex__() calls fail if anything other than a |
| 623 |
complex is returned""" |
| 624 |
def __complex__(self): |
| 625 |
return None |
| 626 |
|
| 627 |
check(complex(complex0(1j)), 0.0, 42.0) |
| 628 |
with self.assertWarns(DeprecationWarning): |
| 629 |
check(complex(complex1(1j)), 0.0, 2.0) |
| 630 |
self.assertRaises(TypeError, complex, complex2(1j)) |
| 631 |
|
| 632 |
def test___complex__(self): |
| 633 |
z = 3 + 4j |
| 634 |
self.assertEqual(z.__complex__(), z) |
| 635 |
self.assertEqual(type(z.__complex__()), complex) |
| 636 |
|
| 637 |
z = ComplexSubclass(3 + 4j) |
| 638 |
self.assertEqual(z.__complex__(), 3 + 4j) |
| 639 |
self.assertEqual(type(z.__complex__()), complex) |
| 640 |
|
| 641 |
@support.requires_IEEE_754 |
| 642 |
def test_constructor_special_numbers(self): |
| 643 |
for x in 0.0, -0.0, INF, -INF, NAN: |
| 644 |
for y in 0.0, -0.0, INF, -INF, NAN: |
| 645 |
with self.subTest(x=x, y=y): |
| 646 |
z = complex(x, y) |
| 647 |
self.assertFloatsAreIdentical(z.real, x) |
| 648 |
self.assertFloatsAreIdentical(z.imag, y) |
| 649 |
z = ComplexSubclass(x, y) |
| 650 |
self.assertIs(type(z), ComplexSubclass) |
| 651 |
self.assertFloatsAreIdentical(z.real, x) |
| 652 |
self.assertFloatsAreIdentical(z.imag, y) |
| 653 |
z = complex(ComplexSubclass(x, y)) |
| 654 |
self.assertIs(type(z), complex) |
| 655 |
self.assertFloatsAreIdentical(z.real, x) |
| 656 |
self.assertFloatsAreIdentical(z.imag, y) |
| 657 |
z = ComplexSubclass(complex(x, y)) |
| 658 |
self.assertIs(type(z), ComplexSubclass) |
| 659 |
self.assertFloatsAreIdentical(z.real, x) |
| 660 |
self.assertFloatsAreIdentical(z.imag, y) |
| 661 |
|
| 662 |
def test_constructor_from_string(self): |
| 663 |
def check(z, x, y): |
| 664 |
self.assertIs(type(z), complex) |
| 665 |
self.assertFloatsAreIdentical(z.real, x) |
| 666 |
self.assertFloatsAreIdentical(z.imag, y) |
| 667 |
|
| 668 |
check(complex("1"), 1.0, 0.0) |
| 669 |
check(complex("1j"), 0.0, 1.0) |
| 670 |
check(complex("-1"), -1.0, 0.0) |
| 671 |
check(complex("+1"), 1.0, 0.0) |
| 672 |
check(complex("1+2j"), 1.0, 2.0) |
| 673 |
check(complex("(1+2j)"), 1.0, 2.0) |
| 674 |
check(complex("(1.5+4.25j)"), 1.5, 4.25) |
| 675 |
check(complex("4.25+1J"), 4.25, 1.0) |
| 676 |
check(complex(" ( +4.25-6J )"), 4.25, -6.0) |
| 677 |
check(complex(" ( +4.25-J )"), 4.25, -1.0) |
| 678 |
check(complex(" ( +4.25+j )"), 4.25, 1.0) |
| 679 |
check(complex("J"), 0.0, 1.0) |
| 680 |
check(complex("( j )"), 0.0, 1.0) |
| 681 |
check(complex("+J"), 0.0, 1.0) |
| 682 |
check(complex("( -j)"), 0.0, -1.0) |
| 683 |
check(complex('1-1j'), 1.0, -1.0) |
| 684 |
check(complex('1J'), 0.0, 1.0) |
| 685 |
|
| 686 |
check(complex('1e-500'), 0.0, 0.0) |
| 687 |
check(complex('-1e-500j'), 0.0, -0.0) |
| 688 |
check(complex('1e-500+1e-500j'), 0.0, 0.0) |
| 689 |
check(complex('-1e-500+1e-500j'), -0.0, 0.0) |
| 690 |
check(complex('1e-500-1e-500j'), 0.0, -0.0) |
| 691 |
check(complex('-1e-500-1e-500j'), -0.0, -0.0) |
| 692 |
|
| 693 |
# SF bug 543840: complex(string) accepts strings with \0 |
| 694 |
# Fixed in 2.3. |
| 695 |
self.assertRaises(ValueError, complex, '1+1j\0j') |
| 696 |
self.assertRaises(ValueError, complex, "") |
| 697 |
self.assertRaises(ValueError, complex, "\0") |
| 698 |
self.assertRaises(ValueError, complex, "3\09") |
| 699 |
self.assertRaises(ValueError, complex, "1+") |
| 700 |
self.assertRaises(ValueError, complex, "1+1j+1j") |
| 701 |
self.assertRaises(ValueError, complex, "--") |
| 702 |
self.assertRaises(ValueError, complex, "(1+2j") |
| 703 |
self.assertRaises(ValueError, complex, "1+2j)") |
| 704 |
self.assertRaises(ValueError, complex, "1+(2j)") |
| 705 |
self.assertRaises(ValueError, complex, "(1+2j)123") |
| 706 |
self.assertRaises(ValueError, complex, "x") |
| 707 |
self.assertRaises(ValueError, complex, "1j+2") |
| 708 |
self.assertRaises(ValueError, complex, "1e1ej") |
| 709 |
self.assertRaises(ValueError, complex, "1e++1ej") |
| 710 |
self.assertRaises(ValueError, complex, ")1+2j(") |
| 711 |
# the following three are accepted by Python 2.6 |
| 712 |
self.assertRaises(ValueError, complex, "1..1j") |
| 713 |
self.assertRaises(ValueError, complex, "1.11.1j") |
| 714 |
self.assertRaises(ValueError, complex, "1e1.1j") |
| 715 |
|
| 716 |
# check that complex accepts long unicode strings |
| 717 |
self.assertIs(type(complex("1"*500)), complex) |
| 718 |
# check whitespace processing |
| 719 |
self.assertEqual(complex('\N{EM SPACE}(\N{EN SPACE}1+1j ) '), 1+1j) |
| 720 |
# Invalid unicode string |
| 721 |
# See bpo-34087 |
| 722 |
self.assertRaises(ValueError, complex, '\u3053\u3093\u306b\u3061\u306f') |
| 723 |
|
| 724 |
def test_constructor_negative_nans_from_string(self): |
| 725 |
self.assertEqual(copysign(1., complex("-nan").real), -1.) |
| 726 |
self.assertEqual(copysign(1., complex("-nanj").imag), -1.) |
| 727 |
self.assertEqual(copysign(1., complex("-nan-nanj").real), -1.) |
| 728 |
self.assertEqual(copysign(1., complex("-nan-nanj").imag), -1.) |
| 729 |
|
| 730 |
def test_underscores(self): |
| 731 |
# check underscores |
| 732 |
for lit in VALID_UNDERSCORE_LITERALS: |
| 733 |
if not any(ch in lit for ch in 'xXoObB'): |
| 734 |
self.assertEqual(complex(lit), eval(lit)) |
| 735 |
self.assertEqual(complex(lit), complex(lit.replace('_', ''))) |
| 736 |
for lit in INVALID_UNDERSCORE_LITERALS: |
| 737 |
if lit in ('0_7', '09_99'): # octals are not recognized here |
| 738 |
continue |
| 739 |
if not any(ch in lit for ch in 'xXoObB'): |
| 740 |
self.assertRaises(ValueError, complex, lit) |
| 741 |
|
| 742 |
def test_from_number(self, cls=complex): |
| 743 |
def eq(actual, expected): |
| 744 |
self.assertEqual(actual, expected) |
| 745 |
self.assertIs(type(actual), cls) |
| 746 |
|
| 747 |
eq(cls.from_number(3.14), 3.14+0j) |
| 748 |
eq(cls.from_number(3.14j), 3.14j) |
| 749 |
eq(cls.from_number(314), 314.0+0j) |
| 750 |
eq(cls.from_number(OtherComplexSubclass(3.14, 2.72)), 3.14+2.72j) |
| 751 |
eq(cls.from_number(WithComplex(3.14+2.72j)), 3.14+2.72j) |
| 752 |
eq(cls.from_number(WithFloat(3.14)), 3.14+0j) |
| 753 |
eq(cls.from_number(WithIndex(314)), 314.0+0j) |
| 754 |
|
| 755 |
cNAN = complex(NAN, NAN) |
| 756 |
x = cls.from_number(cNAN) |
| 757 |
self.assertTrue(x != x) |
| 758 |
self.assertIs(type(x), cls) |
| 759 |
if cls is complex: |
| 760 |
self.assertIs(cls.from_number(cNAN), cNAN) |
| 761 |
|
| 762 |
self.assertRaises(TypeError, cls.from_number, '3.14') |
| 763 |
self.assertRaises(TypeError, cls.from_number, b'3.14') |
| 764 |
self.assertRaises(TypeError, cls.from_number, MyInt(314)) |
| 765 |
self.assertRaises(TypeError, cls.from_number, {}) |
| 766 |
self.assertRaises(TypeError, cls.from_number) |
| 767 |
|
| 768 |
def test_from_number_subclass(self): |
| 769 |
self.test_from_number(ComplexSubclass) |
| 770 |
|
| 771 |
def test_hash(self): |
| 772 |
for x in range(-30, 30): |
| 773 |
self.assertEqual(hash(x), hash(complex(x, 0))) |
| 774 |
x /= 3.0 # now check against floating-point |
| 775 |
self.assertEqual(hash(x), hash(complex(x, 0.))) |
| 776 |
|
| 777 |
self.assertNotEqual(hash(2000005 - 1j), -1) |
| 778 |
|
| 779 |
def test_abs(self): |
| 780 |
nums = [complex(x/3., y/7.) for x in range(-9,9) for y in range(-9,9)] |
| 781 |
for num in nums: |
| 782 |
self.assertAlmostEqual((num.real**2 + num.imag**2) ** 0.5, abs(num)) |
| 783 |
|
| 784 |
self.assertRaises(OverflowError, abs, complex(DBL_MAX, DBL_MAX)) |
| 785 |
|
| 786 |
def test_repr_str(self): |
| 787 |
def test(v, expected, test_fn=self.assertEqual): |
| 788 |
test_fn(repr(v), expected) |
| 789 |
test_fn(str(v), expected) |
| 790 |
|
| 791 |
test(1+6j, '(1+6j)') |
| 792 |
test(1-6j, '(1-6j)') |
| 793 |
|
| 794 |
test(-(1+0j), '(-1+-0j)', test_fn=self.assertNotEqual) |
| 795 |
|
| 796 |
test(complex(1., INF), "(1+infj)") |
| 797 |
test(complex(1., -INF), "(1-infj)") |
| 798 |
test(complex(INF, 1), "(inf+1j)") |
| 799 |
test(complex(-INF, INF), "(-inf+infj)") |
| 800 |
test(complex(NAN, 1), "(nan+1j)") |
| 801 |
test(complex(1, NAN), "(1+nanj)") |
| 802 |
test(complex(NAN, NAN), "(nan+nanj)") |
| 803 |
test(complex(-NAN, -NAN), "(nan+nanj)") |
| 804 |
|
| 805 |
test(complex(0, INF), "infj") |
| 806 |
test(complex(0, -INF), "-infj") |
| 807 |
test(complex(0, NAN), "nanj") |
| 808 |
|
| 809 |
self.assertEqual(1-6j,complex(repr(1-6j))) |
| 810 |
self.assertEqual(1+6j,complex(repr(1+6j))) |
| 811 |
self.assertEqual(-6j,complex(repr(-6j))) |
| 812 |
self.assertEqual(6j,complex(repr(6j))) |
| 813 |
|
| 814 |
@support.requires_IEEE_754 |
| 815 |
def test_negative_zero_repr_str(self): |
| 816 |
def test(v, expected, test_fn=self.assertEqual): |
| 817 |
test_fn(repr(v), expected) |
| 818 |
test_fn(str(v), expected) |
| 819 |
|
| 820 |
test(complex(0., 1.), "1j") |
| 821 |
test(complex(-0., 1.), "(-0+1j)") |
| 822 |
test(complex(0., -1.), "-1j") |
| 823 |
test(complex(-0., -1.), "(-0-1j)") |
| 824 |
|
| 825 |
test(complex(0., 0.), "0j") |
| 826 |
test(complex(0., -0.), "-0j") |
| 827 |
test(complex(-0., 0.), "(-0+0j)") |
| 828 |
test(complex(-0., -0.), "(-0-0j)") |
| 829 |
|
| 830 |
def test_pos(self): |
| 831 |
self.assertEqual(+(1+6j), 1+6j) |
| 832 |
self.assertEqual(+ComplexSubclass(1, 6), 1+6j) |
| 833 |
self.assertIs(type(+ComplexSubclass(1, 6)), complex) |
| 834 |
|
| 835 |
def test_neg(self): |
| 836 |
self.assertEqual(-(1+6j), -1-6j) |
| 837 |
|
| 838 |
def test_getnewargs(self): |
| 839 |
self.assertEqual((1+2j).__getnewargs__(), (1.0, 2.0)) |
| 840 |
self.assertEqual((1-2j).__getnewargs__(), (1.0, -2.0)) |
| 841 |
self.assertEqual((2j).__getnewargs__(), (0.0, 2.0)) |
| 842 |
self.assertEqual((-0j).__getnewargs__(), (0.0, -0.0)) |
| 843 |
self.assertEqual(complex(0, INF).__getnewargs__(), (0.0, INF)) |
| 844 |
self.assertEqual(complex(INF, 0).__getnewargs__(), (INF, 0.0)) |
| 845 |
|
| 846 |
@support.requires_IEEE_754 |
| 847 |
def test_plus_minus_0j(self): |
| 848 |
# test that -0j and 0j literals are not identified |
| 849 |
z1, z2 = 0j, -0j |
| 850 |
self.assertFloatsAreIdentical(z1.imag, 0.0) |
| 851 |
self.assertFloatsAreIdentical(z2.imag, -0.0) |
| 852 |
|
| 853 |
@support.requires_IEEE_754 |
| 854 |
def test_negated_imaginary_literal(self): |
| 855 |
z0 = -0j |
| 856 |
z1 = -7j |
| 857 |
z2 = -1e1000j |
| 858 |
# Note: In versions of Python < 3.2, a negated imaginary literal |
| 859 |
# accidentally ended up with real part 0.0 instead of -0.0, thanks to a |
| 860 |
# modification during CST -> AST translation (see issue #9011). That's |
| 861 |
# fixed in Python 3.2. |
| 862 |
self.assertFloatsAreIdentical(z0.real, -0.0) |
| 863 |
self.assertFloatsAreIdentical(z0.imag, -0.0) |
| 864 |
self.assertFloatsAreIdentical(z1.real, -0.0) |
| 865 |
self.assertFloatsAreIdentical(z1.imag, -7.0) |
| 866 |
self.assertFloatsAreIdentical(z2.real, -0.0) |
| 867 |
self.assertFloatsAreIdentical(z2.imag, -INF) |
| 868 |
|
| 869 |
@support.requires_IEEE_754 |
| 870 |
def test_overflow(self): |
| 871 |
self.assertEqual(complex("1e500"), complex(INF, 0.0)) |
| 872 |
self.assertEqual(complex("-1e500j"), complex(0.0, -INF)) |
| 873 |
self.assertEqual(complex("-1e500+1.8e308j"), complex(-INF, INF)) |
| 874 |
|
| 875 |
@support.requires_IEEE_754 |
| 876 |
def test_repr_roundtrip(self): |
| 877 |
vals = [0.0, 1e-500, 1e-315, 1e-200, 0.0123, 3.1415, 1e50, INF, NAN] |
| 878 |
vals += [-v for v in vals] |
| 879 |
|
| 880 |
# complex(repr(z)) should recover z exactly, even for complex |
| 881 |
# numbers involving an infinity, nan, or negative zero |
| 882 |
for x in vals: |
| 883 |
for y in vals: |
| 884 |
z = complex(x, y) |
| 885 |
roundtrip = complex(repr(z)) |
| 886 |
self.assertComplexesAreIdentical(z, roundtrip) |
| 887 |
|
| 888 |
# if we predefine some constants, then eval(repr(z)) should |
| 889 |
# also work, except that it might change the sign of zeros |
| 890 |
inf, nan = float('inf'), float('nan') |
| 891 |
infj, nanj = complex(0.0, inf), complex(0.0, nan) |
| 892 |
for x in vals: |
| 893 |
for y in vals: |
| 894 |
z = complex(x, y) |
| 895 |
roundtrip = eval(repr(z)) |
| 896 |
# adding 0.0 has no effect beside changing -0.0 to 0.0 |
| 897 |
self.assertFloatsAreIdentical(0.0 + z.real, |
| 898 |
0.0 + roundtrip.real) |
| 899 |
self.assertFloatsAreIdentical(0.0 + z.imag, |
| 900 |
0.0 + roundtrip.imag) |
| 901 |
|
| 902 |
def test_format(self): |
| 903 |
# empty format string is same as str() |
| 904 |
self.assertEqual(format(1+3j, ''), str(1+3j)) |
| 905 |
self.assertEqual(format(1.5+3.5j, ''), str(1.5+3.5j)) |
| 906 |
self.assertEqual(format(3j, ''), str(3j)) |
| 907 |
self.assertEqual(format(3.2j, ''), str(3.2j)) |
| 908 |
self.assertEqual(format(3+0j, ''), str(3+0j)) |
| 909 |
self.assertEqual(format(3.2+0j, ''), str(3.2+0j)) |
| 910 |
|
| 911 |
# empty presentation type should still be analogous to str, |
| 912 |
# even when format string is nonempty (issue #5920). |
| 913 |
self.assertEqual(format(3.2+0j, '-'), str(3.2+0j)) |
| 914 |
self.assertEqual(format(3.2+0j, '<'), str(3.2+0j)) |
| 915 |
z = 4/7. - 100j/7. |
| 916 |
self.assertEqual(format(z, ''), str(z)) |
| 917 |
self.assertEqual(format(z, '-'), str(z)) |
| 918 |
self.assertEqual(format(z, '<'), str(z)) |
| 919 |
self.assertEqual(format(z, '10'), str(z)) |
| 920 |
z = complex(0.0, 3.0) |
| 921 |
self.assertEqual(format(z, ''), str(z)) |
| 922 |
self.assertEqual(format(z, '-'), str(z)) |
| 923 |
self.assertEqual(format(z, '<'), str(z)) |
| 924 |
self.assertEqual(format(z, '2'), str(z)) |
| 925 |
z = complex(-0.0, 2.0) |
| 926 |
self.assertEqual(format(z, ''), str(z)) |
| 927 |
self.assertEqual(format(z, '-'), str(z)) |
| 928 |
self.assertEqual(format(z, '<'), str(z)) |
| 929 |
self.assertEqual(format(z, '3'), str(z)) |
| 930 |
|
| 931 |
self.assertEqual(format(1+3j, 'g'), '1+3j') |
| 932 |
self.assertEqual(format(3j, 'g'), '0+3j') |
| 933 |
self.assertEqual(format(1.5+3.5j, 'g'), '1.5+3.5j') |
| 934 |
|
| 935 |
self.assertEqual(format(1.5+3.5j, '+g'), '+1.5+3.5j') |
| 936 |
self.assertEqual(format(1.5-3.5j, '+g'), '+1.5-3.5j') |
| 937 |
self.assertEqual(format(1.5-3.5j, '-g'), '1.5-3.5j') |
| 938 |
self.assertEqual(format(1.5+3.5j, ' g'), ' 1.5+3.5j') |
| 939 |
self.assertEqual(format(1.5-3.5j, ' g'), ' 1.5-3.5j') |
| 940 |
self.assertEqual(format(-1.5+3.5j, ' g'), '-1.5+3.5j') |
| 941 |
self.assertEqual(format(-1.5-3.5j, ' g'), '-1.5-3.5j') |
| 942 |
|
| 943 |
self.assertEqual(format(-1.5-3.5e-20j, 'g'), '-1.5-3.5e-20j') |
| 944 |
self.assertEqual(format(-1.5-3.5j, 'f'), '-1.500000-3.500000j') |
| 945 |
self.assertEqual(format(-1.5-3.5j, 'F'), '-1.500000-3.500000j') |
| 946 |
self.assertEqual(format(-1.5-3.5j, 'e'), '-1.500000e+00-3.500000e+00j') |
| 947 |
self.assertEqual(format(-1.5-3.5j, '.2e'), '-1.50e+00-3.50e+00j') |
| 948 |
self.assertEqual(format(-1.5-3.5j, '.2E'), '-1.50E+00-3.50E+00j') |
| 949 |
self.assertEqual(format(-1.5e10-3.5e5j, '.2G'), '-1.5E+10-3.5E+05j') |
| 950 |
|
| 951 |
self.assertEqual(format(1.5+3j, '<20g'), '1.5+3j ') |
| 952 |
self.assertEqual(format(1.5+3j, '*<20g'), '1.5+3j**************') |
| 953 |
self.assertEqual(format(1.5+3j, '>20g'), ' 1.5+3j') |
| 954 |
self.assertEqual(format(1.5+3j, '^20g'), ' 1.5+3j ') |
| 955 |
self.assertEqual(format(1.5+3j, '<20'), '(1.5+3j) ') |
| 956 |
self.assertEqual(format(1.5+3j, '>20'), ' (1.5+3j)') |
| 957 |
self.assertEqual(format(1.5+3j, '^20'), ' (1.5+3j) ') |
| 958 |
self.assertEqual(format(1.123-3.123j, '^20.2'), ' (1.1-3.1j) ') |
| 959 |
|
| 960 |
self.assertEqual(format(1.5+3j, '20.2f'), ' 1.50+3.00j') |
| 961 |
self.assertEqual(format(1.5+3j, '>20.2f'), ' 1.50+3.00j') |
| 962 |
self.assertEqual(format(1.5+3j, '<20.2f'), '1.50+3.00j ') |
| 963 |
self.assertEqual(format(1.5e20+3j, '<20.2f'), '150000000000000000000.00+3.00j') |
| 964 |
self.assertEqual(format(1.5e20+3j, '>40.2f'), ' 150000000000000000000.00+3.00j') |
| 965 |
self.assertEqual(format(1.5e20+3j, '^40,.2f'), ' 150,000,000,000,000,000,000.00+3.00j ') |
| 966 |
self.assertEqual(format(1.5e21+3j, '^40,.2f'), ' 1,500,000,000,000,000,000,000.00+3.00j ') |
| 967 |
self.assertEqual(format(1.5e21+3000j, ',.2f'), '1,500,000,000,000,000,000,000.00+3,000.00j') |
| 968 |
|
| 969 |
# Issue 7094: Alternate formatting (specified by #) |
| 970 |
self.assertEqual(format(1+1j, '.0e'), '1e+00+1e+00j') |
| 971 |
self.assertEqual(format(1+1j, '#.0e'), '1.e+00+1.e+00j') |
| 972 |
self.assertEqual(format(1+1j, '.0f'), '1+1j') |
| 973 |
self.assertEqual(format(1+1j, '#.0f'), '1.+1.j') |
| 974 |
self.assertEqual(format(1.1+1.1j, 'g'), '1.1+1.1j') |
| 975 |
self.assertEqual(format(1.1+1.1j, '#g'), '1.10000+1.10000j') |
| 976 |
|
| 977 |
# Alternate doesn't make a difference for these, they format the same with or without it |
| 978 |
self.assertEqual(format(1+1j, '.1e'), '1.0e+00+1.0e+00j') |
| 979 |
self.assertEqual(format(1+1j, '#.1e'), '1.0e+00+1.0e+00j') |
| 980 |
self.assertEqual(format(1+1j, '.1f'), '1.0+1.0j') |
| 981 |
self.assertEqual(format(1+1j, '#.1f'), '1.0+1.0j') |
| 982 |
|
| 983 |
# Misc. other alternate tests |
| 984 |
self.assertEqual(format((-1.5+0.5j), '#f'), '-1.500000+0.500000j') |
| 985 |
self.assertEqual(format((-1.5+0.5j), '#.0f'), '-2.+0.j') |
| 986 |
self.assertEqual(format((-1.5+0.5j), '#e'), '-1.500000e+00+5.000000e-01j') |
| 987 |
self.assertEqual(format((-1.5+0.5j), '#.0e'), '-2.e+00+5.e-01j') |
| 988 |
self.assertEqual(format((-1.5+0.5j), '#g'), '-1.50000+0.500000j') |
| 989 |
self.assertEqual(format((-1.5+0.5j), '.0g'), '-2+0.5j') |
| 990 |
self.assertEqual(format((-1.5+0.5j), '#.0g'), '-2.+0.5j') |
| 991 |
|
| 992 |
# zero padding is invalid |
| 993 |
self.assertRaises(ValueError, (1.5+0.5j).__format__, '010f') |
| 994 |
|
| 995 |
# '=' alignment is invalid |
| 996 |
self.assertRaises(ValueError, (1.5+3j).__format__, '=20') |
| 997 |
|
| 998 |
# integer presentation types are an error |
| 999 |
for t in 'bcdoxX': |
| 1000 |
self.assertRaises(ValueError, (1.5+0.5j).__format__, t) |
| 1001 |
|
| 1002 |
# make sure everything works in ''.format() |
| 1003 |
self.assertEqual('*{0:.3f}*'.format(3.14159+2.71828j), '*3.142+2.718j*') |
| 1004 |
|
| 1005 |
# issue 3382 |
| 1006 |
self.assertEqual(format(complex(NAN, NAN), 'f'), 'nan+nanj') |
| 1007 |
self.assertEqual(format(complex(1, NAN), 'f'), '1.000000+nanj') |
| 1008 |
self.assertEqual(format(complex(NAN, 1), 'f'), 'nan+1.000000j') |
| 1009 |
self.assertEqual(format(complex(NAN, -1), 'f'), 'nan-1.000000j') |
| 1010 |
self.assertEqual(format(complex(NAN, NAN), 'F'), 'NAN+NANj') |
| 1011 |
self.assertEqual(format(complex(1, NAN), 'F'), '1.000000+NANj') |
| 1012 |
self.assertEqual(format(complex(NAN, 1), 'F'), 'NAN+1.000000j') |
| 1013 |
self.assertEqual(format(complex(NAN, -1), 'F'), 'NAN-1.000000j') |
| 1014 |
self.assertEqual(format(complex(INF, INF), 'f'), 'inf+infj') |
| 1015 |
self.assertEqual(format(complex(1, INF), 'f'), '1.000000+infj') |
| 1016 |
self.assertEqual(format(complex(INF, 1), 'f'), 'inf+1.000000j') |
| 1017 |
self.assertEqual(format(complex(INF, -1), 'f'), 'inf-1.000000j') |
| 1018 |
self.assertEqual(format(complex(INF, INF), 'F'), 'INF+INFj') |
| 1019 |
self.assertEqual(format(complex(1, INF), 'F'), '1.000000+INFj') |
| 1020 |
self.assertEqual(format(complex(INF, 1), 'F'), 'INF+1.000000j') |
| 1021 |
self.assertEqual(format(complex(INF, -1), 'F'), 'INF-1.000000j') |
| 1022 |
|
| 1023 |
|
| 1024 |
if __name__ == "__main__": |
| 1025 |
unittest.main() |