Python code coverage for Lib/test/test_cmath.py

#	count	content
1	n/a	from test.support import requires_IEEE_754, cpython_only
2	n/a	from test.test_math import parse_testfile, test_file
3	n/a	import test.test_math as test_math
4	n/a	import unittest
5	n/a	import cmath, math
6	n/a	from cmath import phase, polar, rect, pi
7	n/a	import platform
8	n/a	import sys
9	n/a	import sysconfig
10	n/a
11	n/a	INF = float('inf')
12	n/a	NAN = float('nan')
13	n/a
14	n/a	complex_zeros = [complex(x, y) for x in [0.0, -0.0] for y in [0.0, -0.0]]
15	n/a	complex_infinities = [complex(x, y) for x, y in [
16	n/a	(INF, 0.0), # 1st quadrant
17	n/a	(INF, 2.3),
18	n/a	(INF, INF),
19	n/a	(2.3, INF),
20	n/a	(0.0, INF),
21	n/a	(-0.0, INF), # 2nd quadrant
22	n/a	(-2.3, INF),
23	n/a	(-INF, INF),
24	n/a	(-INF, 2.3),
25	n/a	(-INF, 0.0),
26	n/a	(-INF, -0.0), # 3rd quadrant
27	n/a	(-INF, -2.3),
28	n/a	(-INF, -INF),
29	n/a	(-2.3, -INF),
30	n/a	(-0.0, -INF),
31	n/a	(0.0, -INF), # 4th quadrant
32	n/a	(2.3, -INF),
33	n/a	(INF, -INF),
34	n/a	(INF, -2.3),
35	n/a	(INF, -0.0)
36	n/a	]]
37	n/a	complex_nans = [complex(x, y) for x, y in [
38	n/a	(NAN, -INF),
39	n/a	(NAN, -2.3),
40	n/a	(NAN, -0.0),
41	n/a	(NAN, 0.0),
42	n/a	(NAN, 2.3),
43	n/a	(NAN, INF),
44	n/a	(-INF, NAN),
45	n/a	(-2.3, NAN),
46	n/a	(-0.0, NAN),
47	n/a	(0.0, NAN),
48	n/a	(2.3, NAN),
49	n/a	(INF, NAN)
50	n/a	]]
51	n/a
52	n/a	class CMathTests(unittest.TestCase):
53	n/a	# list of all functions in cmath
54	n/a	test_functions = [getattr(cmath, fname) for fname in [
55	n/a	'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh',
56	n/a	'cos', 'cosh', 'exp', 'log', 'log10', 'sin', 'sinh',
57	n/a	'sqrt', 'tan', 'tanh']]
58	n/a	# test first and second arguments independently for 2-argument log
59	n/a	test_functions.append(lambda x : cmath.log(x, 1729. + 0j))
60	n/a	test_functions.append(lambda x : cmath.log(14.-27j, x))
61	n/a
62	n/a	def setUp(self):
63	n/a	self.test_values = open(test_file)
64	n/a
65	n/a	def tearDown(self):
66	n/a	self.test_values.close()
67	n/a
68	n/a	def assertFloatIdentical(self, x, y):
69	n/a	"""Fail unless floats x and y are identical, in the sense that:
70	n/a	(1) both x and y are nans, or
71	n/a	(2) both x and y are infinities, with the same sign, or
72	n/a	(3) both x and y are zeros, with the same sign, or
73	n/a	(4) x and y are both finite and nonzero, and x == y
74	n/a
75	n/a	"""
76	n/a	msg = 'floats {!r} and {!r} are not identical'
77	n/a
78	n/a	if math.isnan(x) or math.isnan(y):
79	n/a	if math.isnan(x) and math.isnan(y):
80	n/a	return
81	n/a	elif x == y:
82	n/a	if x != 0.0:
83	n/a	return
84	n/a	# both zero; check that signs match
85	n/a	elif math.copysign(1.0, x) == math.copysign(1.0, y):
86	n/a	return
87	n/a	else:
88	n/a	msg += ': zeros have different signs'
89	n/a	self.fail(msg.format(x, y))
90	n/a
91	n/a	def assertComplexIdentical(self, x, y):
92	n/a	"""Fail unless complex numbers x and y have equal values and signs.
93	n/a
94	n/a	In particular, if x and y both have real (or imaginary) part
95	n/a	zero, but the zeros have different signs, this test will fail.
96	n/a
97	n/a	"""
98	n/a	self.assertFloatIdentical(x.real, y.real)
99	n/a	self.assertFloatIdentical(x.imag, y.imag)
100	n/a
101	n/a	def rAssertAlmostEqual(self, a, b, rel_err = 2e-15, abs_err = 5e-323,
102	n/a	msg=None):
103	n/a	"""Fail if the two floating-point numbers are not almost equal.
104	n/a
105	n/a	Determine whether floating-point values a and b are equal to within
106	n/a	a (small) rounding error. The default values for rel_err and
107	n/a	abs_err are chosen to be suitable for platforms where a float is
108	n/a	represented by an IEEE 754 double. They allow an error of between
109	n/a	9 and 19 ulps.
110	n/a	"""
111	n/a
112	n/a	# special values testing
113	n/a	if math.isnan(a):
114	n/a	if math.isnan(b):
115	n/a	return
116	n/a	self.fail(msg or '{!r} should be nan'.format(b))
117	n/a
118	n/a	if math.isinf(a):
119	n/a	if a == b:
120	n/a	return
121	n/a	self.fail(msg or 'finite result where infinity expected: '
122	n/a	'expected {!r}, got {!r}'.format(a, b))
123	n/a
124	n/a	# if both a and b are zero, check whether they have the same sign
125	n/a	# (in theory there are examples where it would be legitimate for a
126	n/a	# and b to have opposite signs; in practice these hardly ever
127	n/a	# occur).
128	n/a	if not a and not b:
129	n/a	if math.copysign(1., a) != math.copysign(1., b):
130	n/a	self.fail(msg or 'zero has wrong sign: expected {!r}, '
131	n/a	'got {!r}'.format(a, b))
132	n/a
133	n/a	# if a-b overflows, or b is infinite, return False. Again, in
134	n/a	# theory there are examples where a is within a few ulps of the
135	n/a	# max representable float, and then b could legitimately be
136	n/a	# infinite. In practice these examples are rare.
137	n/a	try:
138	n/a	absolute_error = abs(b-a)
139	n/a	except OverflowError:
140	n/a	pass
141	n/a	else:
142	n/a	# test passes if either the absolute error or the relative
143	n/a	# error is sufficiently small. The defaults amount to an
144	n/a	# error of between 9 ulps and 19 ulps on an IEEE-754 compliant
145	n/a	# machine.
146	n/a	if absolute_error <= max(abs_err, rel_err * abs(a)):
147	n/a	return
148	n/a	self.fail(msg or
149	n/a	'{!r} and {!r} are not sufficiently close'.format(a, b))
150	n/a
151	n/a	def test_constants(self):
152	n/a	e_expected = 2.71828182845904523536
153	n/a	pi_expected = 3.14159265358979323846
154	n/a	self.assertAlmostEqual(cmath.pi, pi_expected, places=9,
155	n/a	msg="cmath.pi is {}; should be {}".format(cmath.pi, pi_expected))
156	n/a	self.assertAlmostEqual(cmath.e, e_expected, places=9,
157	n/a	msg="cmath.e is {}; should be {}".format(cmath.e, e_expected))
158	n/a
159	n/a	def test_infinity_and_nan_constants(self):
160	n/a	self.assertEqual(cmath.inf.real, math.inf)
161	n/a	self.assertEqual(cmath.inf.imag, 0.0)
162	n/a	self.assertEqual(cmath.infj.real, 0.0)
163	n/a	self.assertEqual(cmath.infj.imag, math.inf)
164	n/a
165	n/a	self.assertTrue(math.isnan(cmath.nan.real))
166	n/a	self.assertEqual(cmath.nan.imag, 0.0)
167	n/a	self.assertEqual(cmath.nanj.real, 0.0)
168	n/a	self.assertTrue(math.isnan(cmath.nanj.imag))
169	n/a
170	n/a	# Check consistency with reprs.
171	n/a	self.assertEqual(repr(cmath.inf), "inf")
172	n/a	self.assertEqual(repr(cmath.infj), "infj")
173	n/a	self.assertEqual(repr(cmath.nan), "nan")
174	n/a	self.assertEqual(repr(cmath.nanj), "nanj")
175	n/a
176	n/a	def test_user_object(self):
177	n/a	# Test automatic calling of __complex__ and __float__ by cmath
178	n/a	# functions
179	n/a
180	n/a	# some random values to use as test values; we avoid values
181	n/a	# for which any of the functions in cmath is undefined
182	n/a	# (i.e. 0., 1., -1., 1j, -1j) or would cause overflow
183	n/a	cx_arg = 4.419414439 + 1.497100113j
184	n/a	flt_arg = -6.131677725
185	n/a
186	n/a	# a variety of non-complex numbers, used to check that
187	n/a	# non-complex return values from __complex__ give an error
188	n/a	non_complexes = ["not complex", 1, 5, 2., None,
189	n/a	object(), NotImplemented]
190	n/a
191	n/a	# Now we introduce a variety of classes whose instances might
192	n/a	# end up being passed to the cmath functions
193	n/a
194	n/a	# usual case: new-style class implementing __complex__
195	n/a	class MyComplex(object):
196	n/a	def __init__(self, value):
197	n/a	self.value = value
198	n/a	def __complex__(self):
199	n/a	return self.value
200	n/a
201	n/a	# old-style class implementing __complex__
202	n/a	class MyComplexOS:
203	n/a	def __init__(self, value):
204	n/a	self.value = value
205	n/a	def __complex__(self):
206	n/a	return self.value
207	n/a
208	n/a	# classes for which __complex__ raises an exception
209	n/a	class SomeException(Exception):
210	n/a	pass
211	n/a	class MyComplexException(object):
212	n/a	def __complex__(self):
213	n/a	raise SomeException
214	n/a	class MyComplexExceptionOS:
215	n/a	def __complex__(self):
216	n/a	raise SomeException
217	n/a
218	n/a	# some classes not providing __float__ or __complex__
219	n/a	class NeitherComplexNorFloat(object):
220	n/a	pass
221	n/a	class NeitherComplexNorFloatOS:
222	n/a	pass
223	n/a	class MyInt(object):
224	n/a	def __int__(self): return 2
225	n/a	def __index__(self): return 2
226	n/a	class MyIntOS:
227	n/a	def __int__(self): return 2
228	n/a	def __index__(self): return 2
229	n/a
230	n/a	# other possible combinations of __float__ and __complex__
231	n/a	# that should work
232	n/a	class FloatAndComplex(object):
233	n/a	def __float__(self):
234	n/a	return flt_arg
235	n/a	def __complex__(self):
236	n/a	return cx_arg
237	n/a	class FloatAndComplexOS:
238	n/a	def __float__(self):
239	n/a	return flt_arg
240	n/a	def __complex__(self):
241	n/a	return cx_arg
242	n/a	class JustFloat(object):
243	n/a	def __float__(self):
244	n/a	return flt_arg
245	n/a	class JustFloatOS:
246	n/a	def __float__(self):
247	n/a	return flt_arg
248	n/a
249	n/a	for f in self.test_functions:
250	n/a	# usual usage
251	n/a	self.assertEqual(f(MyComplex(cx_arg)), f(cx_arg))
252	n/a	self.assertEqual(f(MyComplexOS(cx_arg)), f(cx_arg))
253	n/a	# other combinations of __float__ and __complex__
254	n/a	self.assertEqual(f(FloatAndComplex()), f(cx_arg))
255	n/a	self.assertEqual(f(FloatAndComplexOS()), f(cx_arg))
256	n/a	self.assertEqual(f(JustFloat()), f(flt_arg))
257	n/a	self.assertEqual(f(JustFloatOS()), f(flt_arg))
258	n/a	# TypeError should be raised for classes not providing
259	n/a	# either __complex__ or __float__, even if they provide
260	n/a	# __int__ or __index__. An old-style class
261	n/a	# currently raises AttributeError instead of a TypeError;
262	n/a	# this could be considered a bug.
263	n/a	self.assertRaises(TypeError, f, NeitherComplexNorFloat())
264	n/a	self.assertRaises(TypeError, f, MyInt())
265	n/a	self.assertRaises(Exception, f, NeitherComplexNorFloatOS())
266	n/a	self.assertRaises(Exception, f, MyIntOS())
267	n/a	# non-complex return value from __complex__ -> TypeError
268	n/a	for bad_complex in non_complexes:
269	n/a	self.assertRaises(TypeError, f, MyComplex(bad_complex))
270	n/a	self.assertRaises(TypeError, f, MyComplexOS(bad_complex))
271	n/a	# exceptions in __complex__ should be propagated correctly
272	n/a	self.assertRaises(SomeException, f, MyComplexException())
273	n/a	self.assertRaises(SomeException, f, MyComplexExceptionOS())
274	n/a
275	n/a	def test_input_type(self):
276	n/a	# ints should be acceptable inputs to all cmath
277	n/a	# functions, by virtue of providing a __float__ method
278	n/a	for f in self.test_functions:
279	n/a	for arg in [2, 2.]:
280	n/a	self.assertEqual(f(arg), f(arg.__float__()))
281	n/a
282	n/a	# but strings should give a TypeError
283	n/a	for f in self.test_functions:
284	n/a	for arg in ["a", "long_string", "0", "1j", ""]:
285	n/a	self.assertRaises(TypeError, f, arg)
286	n/a
287	n/a	def test_cmath_matches_math(self):
288	n/a	# check that corresponding cmath and math functions are equal
289	n/a	# for floats in the appropriate range
290	n/a
291	n/a	# test_values in (0, 1)
292	n/a	test_values = [0.01, 0.1, 0.2, 0.5, 0.9, 0.99]
293	n/a
294	n/a	# test_values for functions defined on [-1., 1.]
295	n/a	unit_interval = test_values + [-x for x in test_values] + \
296	n/a	[0., 1., -1.]
297	n/a
298	n/a	# test_values for log, log10, sqrt
299	n/a	positive = test_values + [1.] + [1./x for x in test_values]
300	n/a	nonnegative = [0.] + positive
301	n/a
302	n/a	# test_values for functions defined on the whole real line
303	n/a	real_line = [0.] + positive + [-x for x in positive]
304	n/a
305	n/a	test_functions = {
306	n/a	'acos' : unit_interval,
307	n/a	'asin' : unit_interval,
308	n/a	'atan' : real_line,
309	n/a	'cos' : real_line,
310	n/a	'cosh' : real_line,
311	n/a	'exp' : real_line,
312	n/a	'log' : positive,
313	n/a	'log10' : positive,
314	n/a	'sin' : real_line,
315	n/a	'sinh' : real_line,
316	n/a	'sqrt' : nonnegative,
317	n/a	'tan' : real_line,
318	n/a	'tanh' : real_line}
319	n/a
320	n/a	for fn, values in test_functions.items():
321	n/a	float_fn = getattr(math, fn)
322	n/a	complex_fn = getattr(cmath, fn)
323	n/a	for v in values:
324	n/a	z = complex_fn(v)
325	n/a	self.rAssertAlmostEqual(float_fn(v), z.real)
326	n/a	self.assertEqual(0., z.imag)
327	n/a
328	n/a	# test two-argument version of log with various bases
329	n/a	for base in [0.5, 2., 10.]:
330	n/a	for v in positive:
331	n/a	z = cmath.log(v, base)
332	n/a	self.rAssertAlmostEqual(math.log(v, base), z.real)
333	n/a	self.assertEqual(0., z.imag)
334	n/a
335	n/a	@requires_IEEE_754
336	n/a	def test_specific_values(self):
337	n/a	# Some tests need to be skipped on ancient OS X versions.
338	n/a	# See issue #27953.
339	n/a	SKIP_ON_TIGER = {'tan0064'}
340	n/a
341	n/a	osx_version = None
342	n/a	if sys.platform == 'darwin':
343	n/a	version_txt = platform.mac_ver()[0]
344	n/a	try:
345	n/a	osx_version = tuple(map(int, version_txt.split('.')))
346	n/a	except ValueError:
347	n/a	pass
348	n/a
349	n/a	def rect_complex(z):
350	n/a	"""Wrapped version of rect that accepts a complex number instead of
351	n/a	two float arguments."""
352	n/a	return cmath.rect(z.real, z.imag)
353	n/a
354	n/a	def polar_complex(z):
355	n/a	"""Wrapped version of polar that returns a complex number instead of
356	n/a	two floats."""
357	n/a	return complex(*polar(z))
358	n/a
359	n/a	for id, fn, ar, ai, er, ei, flags in parse_testfile(test_file):
360	n/a	arg = complex(ar, ai)
361	n/a	expected = complex(er, ei)
362	n/a
363	n/a	# Skip certain tests on OS X 10.4.
364	n/a	if osx_version is not None and osx_version < (10, 5):
365	n/a	if id in SKIP_ON_TIGER:
366	n/a	continue
367	n/a
368	n/a	if fn == 'rect':
369	n/a	function = rect_complex
370	n/a	elif fn == 'polar':
371	n/a	function = polar_complex
372	n/a	else:
373	n/a	function = getattr(cmath, fn)
374	n/a	if 'divide-by-zero' in flags or 'invalid' in flags:
375	n/a	try:
376	n/a	actual = function(arg)
377	n/a	except ValueError:
378	n/a	continue
379	n/a	else:
380	n/a	self.fail('ValueError not raised in test '
381	n/a	'{}: {}(complex({!r}, {!r}))'.format(id, fn, ar, ai))
382	n/a
383	n/a	if 'overflow' in flags:
384	n/a	try:
385	n/a	actual = function(arg)
386	n/a	except OverflowError:
387	n/a	continue
388	n/a	else:
389	n/a	self.fail('OverflowError not raised in test '
390	n/a	'{}: {}(complex({!r}, {!r}))'.format(id, fn, ar, ai))
391	n/a
392	n/a	actual = function(arg)
393	n/a
394	n/a	if 'ignore-real-sign' in flags:
395	n/a	actual = complex(abs(actual.real), actual.imag)
396	n/a	expected = complex(abs(expected.real), expected.imag)
397	n/a	if 'ignore-imag-sign' in flags:
398	n/a	actual = complex(actual.real, abs(actual.imag))
399	n/a	expected = complex(expected.real, abs(expected.imag))
400	n/a
401	n/a	# for the real part of the log function, we allow an
402	n/a	# absolute error of up to 2e-15.
403	n/a	if fn in ('log', 'log10'):
404	n/a	real_abs_err = 2e-15
405	n/a	else:
406	n/a	real_abs_err = 5e-323
407	n/a
408	n/a	error_message = (
409	n/a	'{}: {}(complex({!r}, {!r}))\n'
410	n/a	'Expected: complex({!r}, {!r})\n'
411	n/a	'Received: complex({!r}, {!r})\n'
412	n/a	'Received value insufficiently close to expected value.'
413	n/a	).format(id, fn, ar, ai,
414	n/a	expected.real, expected.imag,
415	n/a	actual.real, actual.imag)
416	n/a	self.rAssertAlmostEqual(expected.real, actual.real,
417	n/a	abs_err=real_abs_err,
418	n/a	msg=error_message)
419	n/a	self.rAssertAlmostEqual(expected.imag, actual.imag,
420	n/a	msg=error_message)
421	n/a
422	n/a	def check_polar(self, func):
423	n/a	def check(arg, expected):
424	n/a	got = func(arg)
425	n/a	for e, g in zip(expected, got):
426	n/a	self.rAssertAlmostEqual(e, g)
427	n/a	check(0, (0., 0.))
428	n/a	check(1, (1., 0.))
429	n/a	check(-1, (1., pi))
430	n/a	check(1j, (1., pi / 2))
431	n/a	check(-3j, (3., -pi / 2))
432	n/a	inf = float('inf')
433	n/a	check(complex(inf, 0), (inf, 0.))
434	n/a	check(complex(-inf, 0), (inf, pi))
435	n/a	check(complex(3, inf), (inf, pi / 2))
436	n/a	check(complex(5, -inf), (inf, -pi / 2))
437	n/a	check(complex(inf, inf), (inf, pi / 4))
438	n/a	check(complex(inf, -inf), (inf, -pi / 4))
439	n/a	check(complex(-inf, inf), (inf, 3 * pi / 4))
440	n/a	check(complex(-inf, -inf), (inf, -3 * pi / 4))
441	n/a	nan = float('nan')
442	n/a	check(complex(nan, 0), (nan, nan))
443	n/a	check(complex(0, nan), (nan, nan))
444	n/a	check(complex(nan, nan), (nan, nan))
445	n/a	check(complex(inf, nan), (inf, nan))
446	n/a	check(complex(-inf, nan), (inf, nan))
447	n/a	check(complex(nan, inf), (inf, nan))
448	n/a	check(complex(nan, -inf), (inf, nan))
449	n/a
450	n/a	def test_polar(self):
451	n/a	self.check_polar(polar)
452	n/a
453	n/a	@cpython_only
454	n/a	def test_polar_errno(self):
455	n/a	# Issue #24489: check a previously set C errno doesn't disturb polar()
456	n/a	from _testcapi import set_errno
457	n/a	def polar_with_errno_set(z):
458	n/a	set_errno(11)
459	n/a	try:
460	n/a	return polar(z)
461	n/a	finally:
462	n/a	set_errno(0)
463	n/a	self.check_polar(polar_with_errno_set)
464	n/a
465	n/a	def test_phase(self):
466	n/a	self.assertAlmostEqual(phase(0), 0.)
467	n/a	self.assertAlmostEqual(phase(1.), 0.)
468	n/a	self.assertAlmostEqual(phase(-1.), pi)
469	n/a	self.assertAlmostEqual(phase(-1.+1E-300j), pi)
470	n/a	self.assertAlmostEqual(phase(-1.-1E-300j), -pi)
471	n/a	self.assertAlmostEqual(phase(1j), pi/2)
472	n/a	self.assertAlmostEqual(phase(-1j), -pi/2)
473	n/a
474	n/a	# zeros
475	n/a	self.assertEqual(phase(complex(0.0, 0.0)), 0.0)
476	n/a	self.assertEqual(phase(complex(0.0, -0.0)), -0.0)
477	n/a	self.assertEqual(phase(complex(-0.0, 0.0)), pi)
478	n/a	self.assertEqual(phase(complex(-0.0, -0.0)), -pi)
479	n/a
480	n/a	# infinities
481	n/a	self.assertAlmostEqual(phase(complex(-INF, -0.0)), -pi)
482	n/a	self.assertAlmostEqual(phase(complex(-INF, -2.3)), -pi)
483	n/a	self.assertAlmostEqual(phase(complex(-INF, -INF)), -0.75*pi)
484	n/a	self.assertAlmostEqual(phase(complex(-2.3, -INF)), -pi/2)
485	n/a	self.assertAlmostEqual(phase(complex(-0.0, -INF)), -pi/2)
486	n/a	self.assertAlmostEqual(phase(complex(0.0, -INF)), -pi/2)
487	n/a	self.assertAlmostEqual(phase(complex(2.3, -INF)), -pi/2)
488	n/a	self.assertAlmostEqual(phase(complex(INF, -INF)), -pi/4)
489	n/a	self.assertEqual(phase(complex(INF, -2.3)), -0.0)
490	n/a	self.assertEqual(phase(complex(INF, -0.0)), -0.0)
491	n/a	self.assertEqual(phase(complex(INF, 0.0)), 0.0)
492	n/a	self.assertEqual(phase(complex(INF, 2.3)), 0.0)
493	n/a	self.assertAlmostEqual(phase(complex(INF, INF)), pi/4)
494	n/a	self.assertAlmostEqual(phase(complex(2.3, INF)), pi/2)
495	n/a	self.assertAlmostEqual(phase(complex(0.0, INF)), pi/2)
496	n/a	self.assertAlmostEqual(phase(complex(-0.0, INF)), pi/2)
497	n/a	self.assertAlmostEqual(phase(complex(-2.3, INF)), pi/2)
498	n/a	self.assertAlmostEqual(phase(complex(-INF, INF)), 0.75*pi)
499	n/a	self.assertAlmostEqual(phase(complex(-INF, 2.3)), pi)
500	n/a	self.assertAlmostEqual(phase(complex(-INF, 0.0)), pi)
501	n/a
502	n/a	# real or imaginary part NaN
503	n/a	for z in complex_nans:
504	n/a	self.assertTrue(math.isnan(phase(z)))
505	n/a
506	n/a	def test_abs(self):
507	n/a	# zeros
508	n/a	for z in complex_zeros:
509	n/a	self.assertEqual(abs(z), 0.0)
510	n/a
511	n/a	# infinities
512	n/a	for z in complex_infinities:
513	n/a	self.assertEqual(abs(z), INF)
514	n/a
515	n/a	# real or imaginary part NaN
516	n/a	self.assertEqual(abs(complex(NAN, -INF)), INF)
517	n/a	self.assertTrue(math.isnan(abs(complex(NAN, -2.3))))
518	n/a	self.assertTrue(math.isnan(abs(complex(NAN, -0.0))))
519	n/a	self.assertTrue(math.isnan(abs(complex(NAN, 0.0))))
520	n/a	self.assertTrue(math.isnan(abs(complex(NAN, 2.3))))
521	n/a	self.assertEqual(abs(complex(NAN, INF)), INF)
522	n/a	self.assertEqual(abs(complex(-INF, NAN)), INF)
523	n/a	self.assertTrue(math.isnan(abs(complex(-2.3, NAN))))
524	n/a	self.assertTrue(math.isnan(abs(complex(-0.0, NAN))))
525	n/a	self.assertTrue(math.isnan(abs(complex(0.0, NAN))))
526	n/a	self.assertTrue(math.isnan(abs(complex(2.3, NAN))))
527	n/a	self.assertEqual(abs(complex(INF, NAN)), INF)
528	n/a	self.assertTrue(math.isnan(abs(complex(NAN, NAN))))
529	n/a
530	n/a
531	n/a	@requires_IEEE_754
532	n/a	def test_abs_overflows(self):
533	n/a	# result overflows
534	n/a	self.assertRaises(OverflowError, abs, complex(1.4e308, 1.4e308))
535	n/a
536	n/a	def assertCEqual(self, a, b):
537	n/a	eps = 1E-7
538	n/a	if abs(a.real - b[0]) > eps or abs(a.imag - b[1]) > eps:
539	n/a	self.fail((a ,b))
540	n/a
541	n/a	def test_rect(self):
542	n/a	self.assertCEqual(rect(0, 0), (0, 0))
543	n/a	self.assertCEqual(rect(1, 0), (1., 0))
544	n/a	self.assertCEqual(rect(1, -pi), (-1., 0))
545	n/a	self.assertCEqual(rect(1, pi/2), (0, 1.))
546	n/a	self.assertCEqual(rect(1, -pi/2), (0, -1.))
547	n/a
548	n/a	def test_isfinite(self):
549	n/a	real_vals = [float('-inf'), -2.3, -0.0,
550	n/a	0.0, 2.3, float('inf'), float('nan')]
551	n/a	for x in real_vals:
552	n/a	for y in real_vals:
553	n/a	z = complex(x, y)
554	n/a	self.assertEqual(cmath.isfinite(z),
555	n/a	math.isfinite(x) and math.isfinite(y))
556	n/a
557	n/a	def test_isnan(self):
558	n/a	self.assertFalse(cmath.isnan(1))
559	n/a	self.assertFalse(cmath.isnan(1j))
560	n/a	self.assertFalse(cmath.isnan(INF))
561	n/a	self.assertTrue(cmath.isnan(NAN))
562	n/a	self.assertTrue(cmath.isnan(complex(NAN, 0)))
563	n/a	self.assertTrue(cmath.isnan(complex(0, NAN)))
564	n/a	self.assertTrue(cmath.isnan(complex(NAN, NAN)))
565	n/a	self.assertTrue(cmath.isnan(complex(NAN, INF)))
566	n/a	self.assertTrue(cmath.isnan(complex(INF, NAN)))
567	n/a
568	n/a	def test_isinf(self):
569	n/a	self.assertFalse(cmath.isinf(1))
570	n/a	self.assertFalse(cmath.isinf(1j))
571	n/a	self.assertFalse(cmath.isinf(NAN))
572	n/a	self.assertTrue(cmath.isinf(INF))
573	n/a	self.assertTrue(cmath.isinf(complex(INF, 0)))
574	n/a	self.assertTrue(cmath.isinf(complex(0, INF)))
575	n/a	self.assertTrue(cmath.isinf(complex(INF, INF)))
576	n/a	self.assertTrue(cmath.isinf(complex(NAN, INF)))
577	n/a	self.assertTrue(cmath.isinf(complex(INF, NAN)))
578	n/a
579	n/a	@requires_IEEE_754
580	n/a	@unittest.skipIf(sysconfig.get_config_var('TANH_PRESERVES_ZERO_SIGN') == 0,
581	n/a	"system tanh() function doesn't copy the sign")
582	n/a	def testTanhSign(self):
583	n/a	for z in complex_zeros:
584	n/a	self.assertComplexIdentical(cmath.tanh(z), z)
585	n/a
586	n/a	# The algorithm used for atan and atanh makes use of the system
587	n/a	# log1p function; If that system function doesn't respect the sign
588	n/a	# of zero, then atan and atanh will also have difficulties with
589	n/a	# the sign of complex zeros.
590	n/a	@requires_IEEE_754
591	n/a	def testAtanSign(self):
592	n/a	for z in complex_zeros:
593	n/a	self.assertComplexIdentical(cmath.atan(z), z)
594	n/a
595	n/a	@requires_IEEE_754
596	n/a	def testAtanhSign(self):
597	n/a	for z in complex_zeros:
598	n/a	self.assertComplexIdentical(cmath.atanh(z), z)
599	n/a
600	n/a
601	n/a	class IsCloseTests(test_math.IsCloseTests):
602	n/a	isclose = cmath.isclose
603	n/a
604	n/a	def test_reject_complex_tolerances(self):
605	n/a	with self.assertRaises(TypeError):
606	n/a	self.isclose(1j, 1j, rel_tol=1j)
607	n/a
608	n/a	with self.assertRaises(TypeError):
609	n/a	self.isclose(1j, 1j, abs_tol=1j)
610	n/a
611	n/a	with self.assertRaises(TypeError):
612	n/a	self.isclose(1j, 1j, rel_tol=1j, abs_tol=1j)
613	n/a
614	n/a	def test_complex_values(self):
615	n/a	# test complex values that are close to within 12 decimal places
616	n/a	complex_examples = [(1.0+1.0j, 1.000000000001+1.0j),
617	n/a	(1.0+1.0j, 1.0+1.000000000001j),
618	n/a	(-1.0+1.0j, -1.000000000001+1.0j),
619	n/a	(1.0-1.0j, 1.0-0.999999999999j),
620	n/a	]
621	n/a
622	n/a	self.assertAllClose(complex_examples, rel_tol=1e-12)
623	n/a	self.assertAllNotClose(complex_examples, rel_tol=1e-13)
624	n/a
625	n/a	def test_complex_near_zero(self):
626	n/a	# test values near zero that are near to within three decimal places
627	n/a	near_zero_examples = [(0.001j, 0),
628	n/a	(0.001, 0),
629	n/a	(0.001+0.001j, 0),
630	n/a	(-0.001+0.001j, 0),
631	n/a	(0.001-0.001j, 0),
632	n/a	(-0.001-0.001j, 0),
633	n/a	]
634	n/a
635	n/a	self.assertAllClose(near_zero_examples, abs_tol=1.5e-03)
636	n/a	self.assertAllNotClose(near_zero_examples, abs_tol=0.5e-03)
637	n/a
638	n/a	self.assertIsClose(0.001-0.001j, 0.001+0.001j, abs_tol=2e-03)
639	n/a	self.assertIsNotClose(0.001-0.001j, 0.001+0.001j, abs_tol=1e-03)
640	n/a
641	n/a
642	n/a	if __name__ == "__main__":
643	n/a	unittest.main()