1 from test.test_support import run_unittest

     2 from test.test_math import parse_testfile, test_file

     3 import unittest

     4 import os, sys

     5 import cmath, math

     6 from cmath import phase, polar, rect, pi

     7 

     8 INF = float('inf')

     9 NAN = float('nan')

    10 

    11 complex_zeros = [complex(x, y) for x in [0.0, -0.0] for y in [0.0, -0.0]]

    12 complex_infinities = [complex(x, y) for x, y in [

    13         (INF, 0.0),  # 1st quadrant

    14         (INF, 2.3),

    15         (INF, INF),

    16         (2.3, INF),

    17         (0.0, INF),

    18         (-0.0, INF), # 2nd quadrant

    19         (-2.3, INF),

    20         (-INF, INF),

    21         (-INF, 2.3),

    22         (-INF, 0.0),

    23         (-INF, -0.0), # 3rd quadrant

    24         (-INF, -2.3),

    25         (-INF, -INF),

    26         (-2.3, -INF),

    27         (-0.0, -INF),

    28         (0.0, -INF), # 4th quadrant

    29         (2.3, -INF),

    30         (INF, -INF),

    31         (INF, -2.3),

    32         (INF, -0.0)

    33         ]]

    34 complex_nans = [complex(x, y) for x, y in [

    35         (NAN, -INF),

    36         (NAN, -2.3),

    37         (NAN, -0.0),

    38         (NAN, 0.0),

    39         (NAN, 2.3),

    40         (NAN, INF),

    41         (-INF, NAN),

    42         (-2.3, NAN),

    43         (-0.0, NAN),

    44         (0.0, NAN),

    45         (2.3, NAN),

    46         (INF, NAN)

    47         ]]

    48 

    49 def almostEqualF(a, b, rel_err=2e-15, abs_err = 5e-323):

    50     """Determine whether floating-point values a and b are equal to within

    51     a (small) rounding error.  The default values for rel_err and

    52     abs_err are chosen to be suitable for platforms where a float is

    53     represented by an IEEE 754 double.  They allow an error of between

    54     9 and 19 ulps."""

    55 

    56     # special values testing

    57     if math.isnan(a):

    58         return math.isnan(b)

    59     if math.isinf(a):

    60         return a == b

    61 

    62     # if both a and b are zero, check whether they have the same sign

    63     # (in theory there are examples where it would be legitimate for a

    64     # and b to have opposite signs; in practice these hardly ever

    65     # occur).

    66     if not a and not b:

    67         return math.copysign(1., a) == math.copysign(1., b)

    68 

    69     # if a-b overflows, or b is infinite, return False.  Again, in

    70     # theory there are examples where a is within a few ulps of the

    71     # max representable float, and then b could legitimately be

    72     # infinite.  In practice these examples are rare.

    73     try:

    74         absolute_error = abs(b-a)

    75     except OverflowError:

    76         return False

    77     else:

    78         return absolute_error <= max(abs_err, rel_err * abs(a))

    79 

    80 class CMathTests(unittest.TestCase):

    81     # list of all functions in cmath

    82     test_functions = [getattr(cmath, fname) for fname in [

    83             'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh',

    84             'cos', 'cosh', 'exp', 'log', 'log10', 'sin', 'sinh',

    85             'sqrt', 'tan', 'tanh']]

    86     # test first and second arguments independently for 2-argument log

    87     test_functions.append(lambda x : cmath.log(x, 1729. + 0j))

    88     test_functions.append(lambda x : cmath.log(14.-27j, x))

    89 

    90     def setUp(self):

    91         self.test_values = open(test_file)

    92 

    93     def tearDown(self):

    94         self.test_values.close()

    95 

    96     def rAssertAlmostEqual(self, a, b, rel_err = 2e-15, abs_err = 5e-323):

    97         """Check that two floating-point numbers are almost equal."""

    98 

    99         # special values testing

   100         if math.isnan(a):

   101             if math.isnan(b):

   102                 return

   103             self.fail("%s should be nan" % repr(b))

   104 

   105         if math.isinf(a):

   106             if a == b:

   107                 return

   108             self.fail("finite result where infinity excpected: "

   109                       "expected %s, got %s" % (repr(a), repr(b)))

   110 

   111         if not a and not b:

   112             if math.atan2(a, -1.) != math.atan2(b, -1.):

   113                 self.fail("zero has wrong sign: expected %s, got %s" %

   114                           (repr(a), repr(b)))

   115 

   116         # test passes if either the absolute error or the relative

   117         # error is sufficiently small.  The defaults amount to an

   118         # error of between 9 ulps and 19 ulps on an IEEE-754 compliant

   119         # machine.

   120 

   121         try:

   122             absolute_error = abs(b-a)

   123         except OverflowError:

   124             pass

   125         else:

   126             if absolute_error <= max(abs_err, rel_err * abs(a)):

   127                 return

   128         self.fail("%s and %s are not sufficiently close" % (repr(a), repr(b)))

   129 

   130     def test_constants(self):

   131         e_expected = 2.71828182845904523536

   132         pi_expected = 3.14159265358979323846

   133         self.rAssertAlmostEqual(cmath.pi, pi_expected, 9,

   134             "cmath.pi is %s; should be %s" % (cmath.pi, pi_expected))

   135         self.rAssertAlmostEqual(cmath.e,  e_expected, 9,

   136             "cmath.e is %s; should be %s" % (cmath.e, e_expected))

   137 

   138     def test_user_object(self):

   139         # Test automatic calling of __complex__ and __float__ by cmath

   140         # functions

   141 

   142         # some random values to use as test values; we avoid values

   143         # for which any of the functions in cmath is undefined

   144         # (i.e. 0., 1., -1., 1j, -1j) or would cause overflow

   145         cx_arg = 4.419414439 + 1.497100113j

   146         flt_arg = -6.131677725

   147 

   148         # a variety of non-complex numbers, used to check that

   149         # non-complex return values from __complex__ give an error

   150         non_complexes = ["not complex", 1, 5L, 2., None,

   151                          object(), NotImplemented]

   152 

   153         # Now we introduce a variety of classes whose instances might

   154         # end up being passed to the cmath functions

   155 

   156         # usual case: new-style class implementing __complex__

   157         class MyComplex(object):

   158             def __init__(self, value):

   159                 self.value = value

   160             def __complex__(self):

   161                 return self.value

   162 

   163         # old-style class implementing __complex__

   164         class MyComplexOS:

   165             def __init__(self, value):

   166                 self.value = value

   167             def __complex__(self):

   168                 return self.value

   169 

   170         # classes for which __complex__ raises an exception

   171         class SomeException(Exception):

   172             pass

   173         class MyComplexException(object):

   174             def __complex__(self):

   175                 raise SomeException

   176         class MyComplexExceptionOS:

   177             def __complex__(self):

   178                 raise SomeException

   179 

   180         # some classes not providing __float__ or __complex__

   181         class NeitherComplexNorFloat(object):

   182             pass

   183         class NeitherComplexNorFloatOS:

   184             pass

   185         class MyInt(object):

   186             def __int__(self): return 2

   187             def __long__(self): return 2L

   188             def __index__(self): return 2

   189         class MyIntOS:

   190             def __int__(self): return 2

   191             def __long__(self): return 2L

   192             def __index__(self): return 2

   193 

   194         # other possible combinations of __float__ and __complex__

   195         # that should work

   196         class FloatAndComplex(object):

   197             def __float__(self):

   198                 return flt_arg

   199             def __complex__(self):

   200                 return cx_arg

   201         class FloatAndComplexOS:

   202             def __float__(self):

   203                 return flt_arg

   204             def __complex__(self):

   205                 return cx_arg

   206         class JustFloat(object):

   207             def __float__(self):

   208                 return flt_arg

   209         class JustFloatOS:

   210             def __float__(self):

   211                 return flt_arg

   212 

   213         for f in self.test_functions:

   214             # usual usage

   215             self.assertEqual(f(MyComplex(cx_arg)), f(cx_arg))

   216             self.assertEqual(f(MyComplexOS(cx_arg)), f(cx_arg))

   217             # other combinations of __float__ and __complex__

   218             self.assertEqual(f(FloatAndComplex()), f(cx_arg))

   219             self.assertEqual(f(FloatAndComplexOS()), f(cx_arg))

   220             self.assertEqual(f(JustFloat()), f(flt_arg))

   221             self.assertEqual(f(JustFloatOS()), f(flt_arg))

   222             # TypeError should be raised for classes not providing

   223             # either __complex__ or __float__, even if they provide

   224             # __int__, __long__ or __index__.  An old-style class

   225             # currently raises AttributeError instead of a TypeError;

   226             # this could be considered a bug.

   227             self.assertRaises(TypeError, f, NeitherComplexNorFloat())

   228             self.assertRaises(TypeError, f, MyInt())

   229             self.assertRaises(Exception, f, NeitherComplexNorFloatOS())

   230             self.assertRaises(Exception, f, MyIntOS())

   231             # non-complex return value from __complex__ -> TypeError

   232             for bad_complex in non_complexes:

   233                 self.assertRaises(TypeError, f, MyComplex(bad_complex))

   234                 self.assertRaises(TypeError, f, MyComplexOS(bad_complex))

   235             # exceptions in __complex__ should be propagated correctly

   236             self.assertRaises(SomeException, f, MyComplexException())

   237             self.assertRaises(SomeException, f, MyComplexExceptionOS())

   238 

   239     def test_input_type(self):

   240         # ints and longs should be acceptable inputs to all cmath

   241         # functions, by virtue of providing a __float__ method

   242         for f in self.test_functions:

   243             for arg in [2, 2L, 2.]:

   244                 self.assertEqual(f(arg), f(arg.__float__()))

   245 

   246         # but strings should give a TypeError

   247         for f in self.test_functions:

   248             for arg in ["a", "long_string", "0", "1j", ""]:

   249                 self.assertRaises(TypeError, f, arg)

   250 

   251     def test_cmath_matches_math(self):

   252         # check that corresponding cmath and math functions are equal

   253         # for floats in the appropriate range

   254 

   255         # test_values in (0, 1)

   256         test_values = [0.01, 0.1, 0.2, 0.5, 0.9, 0.99]

   257 

   258         # test_values for functions defined on [-1., 1.]

   259         unit_interval = test_values + [-x for x in test_values] + \

   260             [0., 1., -1.]

   261 

   262         # test_values for log, log10, sqrt

   263         positive = test_values + [1.] + [1./x for x in test_values]

   264         nonnegative = [0.] + positive

   265 

   266         # test_values for functions defined on the whole real line

   267         real_line = [0.] + positive + [-x for x in positive]

   268 

   269         test_functions = {

   270             'acos' : unit_interval,

   271             'asin' : unit_interval,

   272             'atan' : real_line,

   273             'cos' : real_line,

   274             'cosh' : real_line,

   275             'exp' : real_line,

   276             'log' : positive,

   277             'log10' : positive,

   278             'sin' : real_line,

   279             'sinh' : real_line,

   280             'sqrt' : nonnegative,

   281             'tan' : real_line,

   282             'tanh' : real_line}

   283 

   284         for fn, values in test_functions.items():

   285             float_fn = getattr(math, fn)

   286             complex_fn = getattr(cmath, fn)

   287             for v in values:

   288                 z = complex_fn(v)

   289                 self.rAssertAlmostEqual(float_fn(v), z.real)

   290                 self.assertEqual(0., z.imag)

   291 

   292         # test two-argument version of log with various bases

   293         for base in [0.5, 2., 10.]:

   294             for v in positive:

   295                 z = cmath.log(v, base)

   296                 self.rAssertAlmostEqual(math.log(v, base), z.real)

   297                 self.assertEqual(0., z.imag)

   298 

   299     def test_specific_values(self):

   300         if not float.__getformat__("double").startswith("IEEE"):

   301             return

   302 

   303         def rect_complex(z):

   304             """Wrapped version of rect that accepts a complex number instead of

   305             two float arguments."""

   306             return cmath.rect(z.real, z.imag)

   307 

   308         def polar_complex(z):

   309             """Wrapped version of polar that returns a complex number instead of

   310             two floats."""

   311             return complex(*polar(z))

   312 

   313         for id, fn, ar, ai, er, ei, flags in parse_testfile(test_file):

   314             arg = complex(ar, ai)

   315             expected = complex(er, ei)

   316             if fn == 'rect':

   317                 function = rect_complex

   318             elif fn == 'polar':

   319                 function = polar_complex

   320             else:

   321                 function = getattr(cmath, fn)

   322             if 'divide-by-zero' in flags or 'invalid' in flags:

   323                 try:

   324                     actual = function(arg)

   325                 except ValueError:

   326                     continue

   327                 else:

   328                     test_str = "%s: %s(complex(%r, %r))" % (id, fn, ar, ai)

   329                     self.fail('ValueError not raised in test %s' % test_str)

   330 

   331             if 'overflow' in flags:

   332                 try:

   333                     actual = function(arg)

   334                 except OverflowError:

   335                     continue

   336                 else:

   337                     test_str = "%s: %s(complex(%r, %r))" % (id, fn, ar, ai)

   338                     self.fail('OverflowError not raised in test %s' % test_str)

   339 

   340             actual = function(arg)

   341 

   342             if 'ignore-real-sign' in flags:

   343                 actual = complex(abs(actual.real), actual.imag)

   344                 expected = complex(abs(expected.real), expected.imag)

   345             if 'ignore-imag-sign' in flags:

   346                 actual = complex(actual.real, abs(actual.imag))

   347                 expected = complex(expected.real, abs(expected.imag))

   348 

   349             # for the real part of the log function, we allow an

   350             # absolute error of up to 2e-15.

   351             if fn in ('log', 'log10'):

   352                 real_abs_err = 2e-15

   353             else:

   354                 real_abs_err = 5e-323

   355 

   356             if not (almostEqualF(expected.real, actual.real,

   357                                  abs_err = real_abs_err) and

   358                     almostEqualF(expected.imag, actual.imag)):

   359                 error_message = (

   360                     "%s: %s(complex(%r, %r))\n" % (id, fn, ar, ai) +

   361                     "Expected: complex(%r, %r)\n" %

   362                                     (expected.real, expected.imag) +

   363                     "Received: complex(%r, %r)\n" %

   364                                     (actual.real, actual.imag) +

   365                     "Received value insufficiently close to expected value.")

   366                 self.fail(error_message)

   367 

   368     def assertCISEqual(self, a, b):

   369         eps = 1E-7

   370         if abs(a[0] - b[0]) > eps or abs(a[1] - b[1]) > eps:

   371             self.fail((a ,b))

   372 

   373     def test_polar(self):

   374         self.assertCISEqual(polar(0), (0., 0.))

   375         self.assertCISEqual(polar(1.), (1., 0.))

   376         self.assertCISEqual(polar(-1.), (1., pi))

   377         self.assertCISEqual(polar(1j), (1., pi/2))

   378         self.assertCISEqual(polar(-1j), (1., -pi/2))

   379 

   380     def test_phase(self):

   381         self.assertAlmostEqual(phase(0), 0.)

   382         self.assertAlmostEqual(phase(1.), 0.)

   383         self.assertAlmostEqual(phase(-1.), pi)

   384         self.assertAlmostEqual(phase(-1.+1E-300j), pi)

   385         self.assertAlmostEqual(phase(-1.-1E-300j), -pi)

   386         self.assertAlmostEqual(phase(1j), pi/2)

   387         self.assertAlmostEqual(phase(-1j), -pi/2)

   388 

   389         # zeros

   390         self.assertEqual(phase(complex(0.0, 0.0)), 0.0)

   391         self.assertEqual(phase(complex(0.0, -0.0)), -0.0)

   392         self.assertEqual(phase(complex(-0.0, 0.0)), pi)

   393         self.assertEqual(phase(complex(-0.0, -0.0)), -pi)

   394 

   395         # infinities

   396         self.assertAlmostEqual(phase(complex(-INF, -0.0)), -pi)

   397         self.assertAlmostEqual(phase(complex(-INF, -2.3)), -pi)

   398         self.assertAlmostEqual(phase(complex(-INF, -INF)), -0.75*pi)

   399         self.assertAlmostEqual(phase(complex(-2.3, -INF)), -pi/2)

   400         self.assertAlmostEqual(phase(complex(-0.0, -INF)), -pi/2)

   401         self.assertAlmostEqual(phase(complex(0.0, -INF)), -pi/2)

   402         self.assertAlmostEqual(phase(complex(2.3, -INF)), -pi/2)

   403         self.assertAlmostEqual(phase(complex(INF, -INF)), -pi/4)

   404         self.assertEqual(phase(complex(INF, -2.3)), -0.0)

   405         self.assertEqual(phase(complex(INF, -0.0)), -0.0)

   406         self.assertEqual(phase(complex(INF, 0.0)), 0.0)

   407         self.assertEqual(phase(complex(INF, 2.3)), 0.0)

   408         self.assertAlmostEqual(phase(complex(INF, INF)), pi/4)

   409         self.assertAlmostEqual(phase(complex(2.3, INF)), pi/2)

   410         self.assertAlmostEqual(phase(complex(0.0, INF)), pi/2)

   411         self.assertAlmostEqual(phase(complex(-0.0, INF)), pi/2)

   412         self.assertAlmostEqual(phase(complex(-2.3, INF)), pi/2)

   413         self.assertAlmostEqual(phase(complex(-INF, INF)), 0.75*pi)

   414         self.assertAlmostEqual(phase(complex(-INF, 2.3)), pi)

   415         self.assertAlmostEqual(phase(complex(-INF, 0.0)), pi)

   416 

   417         # real or imaginary part NaN

   418         for z in complex_nans:

   419             self.assert_(math.isnan(phase(z)))

   420 

   421     def test_abs(self):

   422         # zeros

   423         for z in complex_zeros:

   424             self.assertEqual(abs(z), 0.0)

   425 

   426         # infinities

   427         for z in complex_infinities:

   428             self.assertEqual(abs(z), INF)

   429 

   430         # real or imaginary part NaN

   431         self.assertEqual(abs(complex(NAN, -INF)), INF)

   432         self.assert_(math.isnan(abs(complex(NAN, -2.3))))

   433         self.assert_(math.isnan(abs(complex(NAN, -0.0))))

   434         self.assert_(math.isnan(abs(complex(NAN, 0.0))))

   435         self.assert_(math.isnan(abs(complex(NAN, 2.3))))

   436         self.assertEqual(abs(complex(NAN, INF)), INF)

   437         self.assertEqual(abs(complex(-INF, NAN)), INF)

   438         self.assert_(math.isnan(abs(complex(-2.3, NAN))))

   439         self.assert_(math.isnan(abs(complex(-0.0, NAN))))

   440         self.assert_(math.isnan(abs(complex(0.0, NAN))))

   441         self.assert_(math.isnan(abs(complex(2.3, NAN))))

   442         self.assertEqual(abs(complex(INF, NAN)), INF)

   443         self.assert_(math.isnan(abs(complex(NAN, NAN))))

   444 

   445         # result overflows

   446         if float.__getformat__("double").startswith("IEEE"):

   447             self.assertRaises(OverflowError, abs, complex(1.4e308, 1.4e308))

   448 

   449     def assertCEqual(self, a, b):

   450         eps = 1E-7

   451         if abs(a.real - b[0]) > eps or abs(a.imag - b[1]) > eps:

   452             self.fail((a ,b))

   453 

   454     def test_rect(self):

   455         self.assertCEqual(rect(0, 0), (0, 0))

   456         self.assertCEqual(rect(1, 0), (1., 0))

   457         self.assertCEqual(rect(1, -pi), (-1., 0))

   458         self.assertCEqual(rect(1, pi/2), (0, 1.))

   459         self.assertCEqual(rect(1, -pi/2), (0, -1.))

   460 

   461     def test_isnan(self):

   462         self.failIf(cmath.isnan(1))

   463         self.failIf(cmath.isnan(1j))

   464         self.failIf(cmath.isnan(INF))

   465         self.assert_(cmath.isnan(NAN))

   466         self.assert_(cmath.isnan(complex(NAN, 0)))

   467         self.assert_(cmath.isnan(complex(0, NAN)))

   468         self.assert_(cmath.isnan(complex(NAN, NAN)))

   469         self.assert_(cmath.isnan(complex(NAN, INF)))

   470         self.assert_(cmath.isnan(complex(INF, NAN)))

   471 

   472     def test_isinf(self):

   473         self.failIf(cmath.isinf(1))

   474         self.failIf(cmath.isinf(1j))

   475         self.failIf(cmath.isinf(NAN))

   476         self.assert_(cmath.isinf(INF))

   477         self.assert_(cmath.isinf(complex(INF, 0)))

   478         self.assert_(cmath.isinf(complex(0, INF)))

   479         self.assert_(cmath.isinf(complex(INF, INF)))

   480         self.assert_(cmath.isinf(complex(NAN, INF)))

   481         self.assert_(cmath.isinf(complex(INF, NAN)))

   482 

   483 

   484 def test_main():

   485     run_unittest(CMathTests)

   486 

   487 if __name__ == "__main__":

   488     test_main()