# Python test set -- math module

# XXXX Should not do tests around zero only

from test.test_support import run_unittest, verbose

import unittest

import math

import os

import sys

import random

eps = 1E-05

NAN = float('nan')

INF = float('inf')

NINF = float('-inf')

# locate file with test values

if __name__ == '__main__':

    file = sys.argv[0]

else:

    file = __file__

test_dir = os.path.dirname(file) or os.curdir

test_file = os.path.join(test_dir, 'cmath_testcases.txt')

def parse_testfile(fname):

    """Parse a file with test values

    Empty lines or lines starting with -- are ignored

    yields id, fn, arg_real, arg_imag, exp_real, exp_imag

    """

    with open(fname) as fp:

        for line in fp:

            # skip comment lines and blank lines

            if line.startswith('--') or not line.strip():

                continue

            lhs, rhs = line.split('->')

            id, fn, arg_real, arg_imag = lhs.split()

            rhs_pieces = rhs.split()

            exp_real, exp_imag = rhs_pieces[0], rhs_pieces[1]

            flags = rhs_pieces[2:]

            yield (id, fn,

                   float(arg_real), float(arg_imag),

                   float(exp_real), float(exp_imag),

                   flags

                  )

class MathTests(unittest.TestCase):

    def ftest(self, name, value, expected):

        if abs(value-expected) > eps:

            # Use %r instead of %f so the error message

            # displays full precision. Otherwise discrepancies

            # in the last few bits will lead to very confusing

            # error messages

            self.fail('%s returned %r, expected %r' %

                      (name, value, expected))

    def testConstants(self):

        self.ftest('pi', math.pi, 3.1415926)

        self.ftest('e', math.e, 2.7182818)

    def testAcos(self):

        self.assertRaises(TypeError, math.acos)

        self.ftest('acos(-1)', math.acos(-1), math.pi)

        self.ftest('acos(0)', math.acos(0), math.pi/2)

        self.ftest('acos(1)', math.acos(1), 0)

        self.assertRaises(ValueError, math.acos, INF)

        self.assertRaises(ValueError, math.acos, NINF)

        self.assert_(math.isnan(math.acos(NAN)))

    def testAcosh(self):

        self.assertRaises(TypeError, math.acosh)

        self.ftest('acosh(1)', math.acosh(1), 0)

        self.ftest('acosh(2)', math.acosh(2), 1.3169578969248168)

        self.assertRaises(ValueError, math.acosh, 0)

        self.assertRaises(ValueError, math.acosh, -1)

        self.assertEquals(math.acosh(INF), INF)

        self.assertRaises(ValueError, math.acosh, NINF)

        self.assert_(math.isnan(math.acosh(NAN)))

    def testAsin(self):

        self.assertRaises(TypeError, math.asin)

        self.ftest('asin(-1)', math.asin(-1), -math.pi/2)

        self.ftest('asin(0)', math.asin(0), 0)

        self.ftest('asin(1)', math.asin(1), math.pi/2)

        self.assertRaises(ValueError, math.asin, INF)

        self.assertRaises(ValueError, math.asin, NINF)

        self.assert_(math.isnan(math.asin(NAN)))

    def testAsinh(self):

        self.assertRaises(TypeError, math.asinh)

        self.ftest('asinh(0)', math.asinh(0), 0)

        self.ftest('asinh(1)', math.asinh(1), 0.88137358701954305)

        self.ftest('asinh(-1)', math.asinh(-1), -0.88137358701954305)

        self.assertEquals(math.asinh(INF), INF)

        self.assertEquals(math.asinh(NINF), NINF)

        self.assert_(math.isnan(math.asinh(NAN)))

    def testAtan(self):

        self.assertRaises(TypeError, math.atan)

        self.ftest('atan(-1)', math.atan(-1), -math.pi/4)

        self.ftest('atan(0)', math.atan(0), 0)

        self.ftest('atan(1)', math.atan(1), math.pi/4)

        self.ftest('atan(inf)', math.atan(INF), math.pi/2)

        self.ftest('atan(-inf)', math.atan(NINF), -math.pi/2)

        self.assert_(math.isnan(math.atan(NAN)))

    def testAtanh(self):

        self.assertRaises(TypeError, math.atan)

        self.ftest('atanh(0)', math.atanh(0), 0)

        self.ftest('atanh(0.5)', math.atanh(0.5), 0.54930614433405489)

        self.ftest('atanh(-0.5)', math.atanh(-0.5), -0.54930614433405489)

        self.assertRaises(ValueError, math.atanh, 1)

        self.assertRaises(ValueError, math.atanh, -1)

        self.assertRaises(ValueError, math.atanh, INF)

        self.assertRaises(ValueError, math.atanh, NINF)

        self.assert_(math.isnan(math.atanh(NAN)))

    def testAtan2(self):

        self.assertRaises(TypeError, math.atan2)

        self.ftest('atan2(-1, 0)', math.atan2(-1, 0), -math.pi/2)

        self.ftest('atan2(-1, 1)', math.atan2(-1, 1), -math.pi/4)

        self.ftest('atan2(0, 1)', math.atan2(0, 1), 0)

        self.ftest('atan2(1, 1)', math.atan2(1, 1), math.pi/4)

        self.ftest('atan2(1, 0)', math.atan2(1, 0), math.pi/2)

        # math.atan2(0, x)

        self.ftest('atan2(0., -inf)', math.atan2(0., NINF), math.pi)

        self.ftest('atan2(0., -2.3)', math.atan2(0., -2.3), math.pi)

        self.ftest('atan2(0., -0.)', math.atan2(0., -0.), math.pi)

        self.assertEqual(math.atan2(0., 0.), 0.)

        self.assertEqual(math.atan2(0., 2.3), 0.)

        self.assertEqual(math.atan2(0., INF), 0.)

        self.assert_(math.isnan(math.atan2(0., NAN)))

        # math.atan2(-0, x)

        self.ftest('atan2(-0., -inf)', math.atan2(-0., NINF), -math.pi)

        self.ftest('atan2(-0., -2.3)', math.atan2(-0., -2.3), -math.pi)

        self.ftest('atan2(-0., -0.)', math.atan2(-0., -0.), -math.pi)

        self.assertEqual(math.atan2(-0., 0.), -0.)

        self.assertEqual(math.atan2(-0., 2.3), -0.)

        self.assertEqual(math.atan2(-0., INF), -0.)

        self.assert_(math.isnan(math.atan2(-0., NAN)))

        # math.atan2(INF, x)

        self.ftest('atan2(inf, -inf)', math.atan2(INF, NINF), math.pi*3/4)

        self.ftest('atan2(inf, -2.3)', math.atan2(INF, -2.3), math.pi/2)

        self.ftest('atan2(inf, -0.)', math.atan2(INF, -0.0), math.pi/2)

        self.ftest('atan2(inf, 0.)', math.atan2(INF, 0.0), math.pi/2)

        self.ftest('atan2(inf, 2.3)', math.atan2(INF, 2.3), math.pi/2)

        self.ftest('atan2(inf, inf)', math.atan2(INF, INF), math.pi/4)

        self.assert_(math.isnan(math.atan2(INF, NAN)))

        # math.atan2(NINF, x)

        self.ftest('atan2(-inf, -inf)', math.atan2(NINF, NINF), -math.pi*3/4)

        self.ftest('atan2(-inf, -2.3)', math.atan2(NINF, -2.3), -math.pi/2)

        self.ftest('atan2(-inf, -0.)', math.atan2(NINF, -0.0), -math.pi/2)

        self.ftest('atan2(-inf, 0.)', math.atan2(NINF, 0.0), -math.pi/2)

        self.ftest('atan2(-inf, 2.3)', math.atan2(NINF, 2.3), -math.pi/2)

        self.ftest('atan2(-inf, inf)', math.atan2(NINF, INF), -math.pi/4)

        self.assert_(math.isnan(math.atan2(NINF, NAN)))

        # math.atan2(+finite, x)

        self.ftest('atan2(2.3, -inf)', math.atan2(2.3, NINF), math.pi)

        self.ftest('atan2(2.3, -0.)', math.atan2(2.3, -0.), math.pi/2)

        self.ftest('atan2(2.3, 0.)', math.atan2(2.3, 0.), math.pi/2)

        self.assertEqual(math.atan2(2.3, INF), 0.)

        self.assert_(math.isnan(math.atan2(2.3, NAN)))

        # math.atan2(-finite, x)

        self.ftest('atan2(-2.3, -inf)', math.atan2(-2.3, NINF), -math.pi)

        self.ftest('atan2(-2.3, -0.)', math.atan2(-2.3, -0.), -math.pi/2)

        self.ftest('atan2(-2.3, 0.)', math.atan2(-2.3, 0.), -math.pi/2)

        self.assertEqual(math.atan2(-2.3, INF), -0.)

        self.assert_(math.isnan(math.atan2(-2.3, NAN)))

        # math.atan2(NAN, x)

        self.assert_(math.isnan(math.atan2(NAN, NINF)))

        self.assert_(math.isnan(math.atan2(NAN, -2.3)))

        self.assert_(math.isnan(math.atan2(NAN, -0.)))

        self.assert_(math.isnan(math.atan2(NAN, 0.)))

        self.assert_(math.isnan(math.atan2(NAN, 2.3)))

        self.assert_(math.isnan(math.atan2(NAN, INF)))

        self.assert_(math.isnan(math.atan2(NAN, NAN)))

    def testCeil(self):

        self.assertRaises(TypeError, math.ceil)

        # These types will be int in py3k.

        self.assertEquals(float, type(math.ceil(1)))

        self.assertEquals(float, type(math.ceil(1L)))

        self.assertEquals(float, type(math.ceil(1.0)))

        self.ftest('ceil(0.5)', math.ceil(0.5), 1)

        self.ftest('ceil(1.0)', math.ceil(1.0), 1)

        self.ftest('ceil(1.5)', math.ceil(1.5), 2)

        self.ftest('ceil(-0.5)', math.ceil(-0.5), 0)

        self.ftest('ceil(-1.0)', math.ceil(-1.0), -1)

        self.ftest('ceil(-1.5)', math.ceil(-1.5), -1)

        self.assertEquals(math.ceil(INF), INF)

        self.assertEquals(math.ceil(NINF), NINF)

        self.assert_(math.isnan(math.ceil(NAN)))

        class TestCeil(object):

            def __float__(self):

                return 41.3

        class TestNoCeil(object):

            pass

        self.ftest('ceil(TestCeil())', math.ceil(TestCeil()), 42)

        self.assertRaises(TypeError, math.ceil, TestNoCeil())

        t = TestNoCeil()

        t.__ceil__ = lambda *args: args

        self.assertRaises(TypeError, math.ceil, t)

        self.assertRaises(TypeError, math.ceil, t, 0)

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

        def testCopysign(self):

            self.assertRaises(TypeError, math.copysign)

            # copysign should let us distinguish signs of zeros

            self.assertEquals(copysign(1., 0.), 1.)

            self.assertEquals(copysign(1., -0.), -1.)

            self.assertEquals(copysign(INF, 0.), INF)

            self.assertEquals(copysign(INF, -0.), NINF)

            self.assertEquals(copysign(NINF, 0.), INF)

            self.assertEquals(copysign(NINF, -0.), NINF)

            # and of infinities

            self.assertEquals(copysign(1., INF), 1.)

            self.assertEquals(copysign(1., NINF), -1.)

            self.assertEquals(copysign(INF, INF), INF)

            self.assertEquals(copysign(INF, NINF), NINF)

            self.assertEquals(copysign(NINF, INF), INF)

            self.assertEquals(copysign(NINF, NINF), NINF)

            self.assert_(math.isnan(copysign(NAN, 1.)))

            self.assert_(math.isnan(copysign(NAN, INF)))

            self.assert_(math.isnan(copysign(NAN, NINF)))

            self.assert_(math.isnan(copysign(NAN, NAN)))

            # copysign(INF, NAN) may be INF or it may be NINF, since

            # we don't know whether the sign bit of NAN is set on any

            # given platform.

            self.assert_(math.isinf(copysign(INF, NAN)))

            # similarly, copysign(2., NAN) could be 2. or -2.

            self.assertEquals(abs(copysign(2., NAN)), 2.)

    def testCos(self):

        self.assertRaises(TypeError, math.cos)

        self.ftest('cos(-pi/2)', math.cos(-math.pi/2), 0)

        self.ftest('cos(0)', math.cos(0), 1)

        self.ftest('cos(pi/2)', math.cos(math.pi/2), 0)

        self.ftest('cos(pi)', math.cos(math.pi), -1)

        try:

            self.assert_(math.isnan(math.cos(INF)))

            self.assert_(math.isnan(math.cos(NINF)))

        except ValueError:

            self.assertRaises(ValueError, math.cos, INF)

            self.assertRaises(ValueError, math.cos, NINF)

        self.assert_(math.isnan(math.cos(NAN)))

    def testCosh(self):

        self.assertRaises(TypeError, math.cosh)

        self.ftest('cosh(0)', math.cosh(0), 1)

        self.ftest('cosh(2)-2*cosh(1)**2', math.cosh(2)-2*math.cosh(1)**2, -1) # Thanks to Lambert

        self.assertEquals(math.cosh(INF), INF)

        self.assertEquals(math.cosh(NINF), INF)

        self.assert_(math.isnan(math.cosh(NAN)))

    def testDegrees(self):

        self.assertRaises(TypeError, math.degrees)

        self.ftest('degrees(pi)', math.degrees(math.pi), 180.0)

        self.ftest('degrees(pi/2)', math.degrees(math.pi/2), 90.0)

        self.ftest('degrees(-pi/4)', math.degrees(-math.pi/4), -45.0)

    def testExp(self):

        self.assertRaises(TypeError, math.exp)

        self.ftest('exp(-1)', math.exp(-1), 1/math.e)

        self.ftest('exp(0)', math.exp(0), 1)

        self.ftest('exp(1)', math.exp(1), math.e)

        self.assertEquals(math.exp(INF), INF)

        self.assertEquals(math.exp(NINF), 0.)

        self.assert_(math.isnan(math.exp(NAN)))

    def testFabs(self):

        self.assertRaises(TypeError, math.fabs)

        self.ftest('fabs(-1)', math.fabs(-1), 1)

        self.ftest('fabs(0)', math.fabs(0), 0)

        self.ftest('fabs(1)', math.fabs(1), 1)

    def testFactorial(self):

        def fact(n):

            result = 1

            for i in range(1, int(n)+1):

                result *= i

            return result

        values = range(10) + [50, 100, 500]

        random.shuffle(values)

        for x in range(10):

            for cast in (int, long, float):

                self.assertEqual(math.factorial(cast(x)), fact(x), (x, fact(x), math.factorial(x)))

        self.assertRaises(ValueError, math.factorial, -1)

        self.assertRaises(ValueError, math.factorial, math.pi)

    def testFloor(self):

        self.assertRaises(TypeError, math.floor)

        # These types will be int in py3k.

        self.assertEquals(float, type(math.floor(1)))

        self.assertEquals(float, type(math.floor(1L)))

        self.assertEquals(float, type(math.floor(1.0)))

        self.ftest('floor(0.5)', math.floor(0.5), 0)

        self.ftest('floor(1.0)', math.floor(1.0), 1)

        self.ftest('floor(1.5)', math.floor(1.5), 1)

        self.ftest('floor(-0.5)', math.floor(-0.5), -1)

        self.ftest('floor(-1.0)', math.floor(-1.0), -1)

        self.ftest('floor(-1.5)', math.floor(-1.5), -2)

        # pow() relies on floor() to check for integers

        # This fails on some platforms - so check it here

        self.ftest('floor(1.23e167)', math.floor(1.23e167), 1.23e167)

        self.ftest('floor(-1.23e167)', math.floor(-1.23e167), -1.23e167)

        self.assertEquals(math.ceil(INF), INF)

        self.assertEquals(math.ceil(NINF), NINF)

        self.assert_(math.isnan(math.floor(NAN)))

        class TestFloor(object):

            def __float__(self):

                return 42.3

        class TestNoFloor(object):

            pass

        self.ftest('floor(TestFloor())', math.floor(TestFloor()), 42)

        self.assertRaises(TypeError, math.floor, TestNoFloor())

        t = TestNoFloor()

        t.__floor__ = lambda *args: args

        self.assertRaises(TypeError, math.floor, t)

        self.assertRaises(TypeError, math.floor, t, 0)

    def testFmod(self):

        self.assertRaises(TypeError, math.fmod)

        self.ftest('fmod(10,1)', math.fmod(10,1), 0)

        self.ftest('fmod(10,0.5)', math.fmod(10,0.5), 0)

        self.ftest('fmod(10,1.5)', math.fmod(10,1.5), 1)

        self.ftest('fmod(-10,1)', math.fmod(-10,1), 0)

        self.ftest('fmod(-10,0.5)', math.fmod(-10,0.5), 0)

        self.ftest('fmod(-10,1.5)', math.fmod(-10,1.5), -1)

        self.assert_(math.isnan(math.fmod(NAN, 1.)))

        self.assert_(math.isnan(math.fmod(1., NAN)))

        self.assert_(math.isnan(math.fmod(NAN, NAN)))

        self.assertRaises(ValueError, math.fmod, 1., 0.)

        self.assertRaises(ValueError, math.fmod, INF, 1.)

        self.assertRaises(ValueError, math.fmod, NINF, 1.)

        self.assertRaises(ValueError, math.fmod, INF, 0.)

        self.assertEquals(math.fmod(3.0, INF), 3.0)

        self.assertEquals(math.fmod(-3.0, INF), -3.0)

        self.assertEquals(math.fmod(3.0, NINF), 3.0)

        self.assertEquals(math.fmod(-3.0, NINF), -3.0)

        self.assertEquals(math.fmod(0.0, 3.0), 0.0)

        self.assertEquals(math.fmod(0.0, NINF), 0.0)

    def testFrexp(self):

        self.assertRaises(TypeError, math.frexp)

        def testfrexp(name, (mant, exp), (emant, eexp)):

            if abs(mant-emant) > eps or exp != eexp:

                self.fail('%s returned %r, expected %r'%\

                          (name, (mant, exp), (emant,eexp)))

        testfrexp('frexp(-1)', math.frexp(-1), (-0.5, 1))

        testfrexp('frexp(0)', math.frexp(0), (0, 0))

        testfrexp('frexp(1)', math.frexp(1), (0.5, 1))

        testfrexp('frexp(2)', math.frexp(2), (0.5, 2))

        self.assertEquals(math.frexp(INF)[0], INF)

        self.assertEquals(math.frexp(NINF)[0], NINF)

        self.assert_(math.isnan(math.frexp(NAN)[0]))

    def testFsum(self):

        # math.fsum relies on exact rounding for correct operation.

        # There's a known problem with IA32 floating-point that causes

        # inexact rounding in some situations, and will cause the

        # math.fsum tests below to fail; see issue #2937.  On non IEEE

        # 754 platforms, and on IEEE 754 platforms that exhibit the

        # problem described in issue #2937, we simply skip the whole

        # test.

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

            return

        # on IEEE 754 compliant machines, both of the expressions

        # below should round to 10000000000000002.0.

        if 1e16+2.0 != 1e16+2.9999:

            return

        # Python version of math.fsum, for comparison.  Uses a

        # different algorithm based on frexp, ldexp and integer

        # arithmetic.

        from sys import float_info

        mant_dig = float_info.mant_dig

        etiny = float_info.min_exp - mant_dig

        def msum(iterable):

            """Full precision summation.  Compute sum(iterable) without any

            intermediate accumulation of error.  Based on the 'lsum' function

            at http://code.activestate.com/recipes/393090/

            """

            tmant, texp = 0, 0

            for x in iterable:

                mant, exp = math.frexp(x)

                mant, exp = int(math.ldexp(mant, mant_dig)), exp - mant_dig

                if texp > exp:

                    tmant <<= texp-exp

                    texp = exp

                else:

                    mant <<= exp-texp

                tmant += mant

            # Round tmant * 2**texp to a float.  The original recipe

            # used float(str(tmant)) * 2.0**texp for this, but that's

            # a little unsafe because str -> float conversion can't be

            # relied upon to do correct rounding on all platforms.

            tail = max(len(bin(abs(tmant)))-2 - mant_dig, etiny - texp)

            if tail > 0:

                h = 1 << (tail-1)

                tmant = tmant // (2*h) + bool(tmant & h and tmant & 3*h-1)

                texp += tail

            return math.ldexp(tmant, texp)

        test_values = [

            ([], 0.0),

            ([0.0], 0.0),

            ([1e100, 1.0, -1e100, 1e-100, 1e50, -1.0, -1e50], 1e-100),

            ([2.0**53, -0.5, -2.0**-54], 2.0**53-1.0),

            ([2.0**53, 1.0, 2.0**-100], 2.0**53+2.0),

            ([2.0**53+10.0, 1.0, 2.0**-100], 2.0**53+12.0),

            ([2.0**53-4.0, 0.5, 2.0**-54], 2.0**53-3.0),

            ([1./n for n in range(1, 1001)],

             float.fromhex('0x1.df11f45f4e61ap+2')),

            ([(-1.)**n/n for n in range(1, 1001)],

             float.fromhex('-0x1.62a2af1bd3624p-1')),

            ([1.7**(i+1)-1.7**i for i in range(1000)] + [-1.7**1000], -1.0),

            ([1e16, 1., 1e-16], 10000000000000002.0),

            ([1e16-2., 1.-2.**-53, -(1e16-2.), -(1.-2.**-53)], 0.0),

            # exercise code for resizing partials array

            ([2.**n - 2.**(n+50) + 2.**(n+52) for n in range(-1074, 972, 2)] +

             [-2.**1022],

             float.fromhex('0x1.5555555555555p+970')),

            ]

        for i, (vals, expected) in enumerate(test_values):

            try:

                actual = math.fsum(vals)

            except OverflowError:

                self.fail("test %d failed: got OverflowError, expected %r "

                          "for math.fsum(%.100r)" % (i, expected, vals))

            except ValueError:

                self.fail("test %d failed: got ValueError, expected %r "

                          "for math.fsum(%.100r)" % (i, expected, vals))

            self.assertEqual(actual, expected)

        from random import random, gauss, shuffle

        for j in xrange(1000):

            vals = [7, 1e100, -7, -1e100, -9e-20, 8e-20] * 10

            s = 0

            for i in xrange(200):

                v = gauss(0, random()) ** 7 - s

                s += v

                vals.append(v)

            shuffle(vals)

            s = msum(vals)

            self.assertEqual(msum(vals), math.fsum(vals))

    def testHypot(self):

        self.assertRaises(TypeError, math.hypot)

        self.ftest('hypot(0,0)', math.hypot(0,0), 0)

        self.ftest('hypot(3,4)', math.hypot(3,4), 5)

        self.assertEqual(math.hypot(NAN, INF), INF)

        self.assertEqual(math.hypot(INF, NAN), INF)

        self.assertEqual(math.hypot(NAN, NINF), INF)

        self.assertEqual(math.hypot(NINF, NAN), INF)

        self.assert_(math.isnan(math.hypot(1.0, NAN)))

        self.assert_(math.isnan(math.hypot(NAN, -2.0)))

    def testLdexp(self):

        self.assertRaises(TypeError, math.ldexp)

        self.ftest('ldexp(0,1)', math.ldexp(0,1), 0)

        self.ftest('ldexp(1,1)', math.ldexp(1,1), 2)

        self.ftest('ldexp(1,-1)', math.ldexp(1,-1), 0.5)

        self.ftest('ldexp(-1,1)', math.ldexp(-1,1), -2)

        self.assertRaises(OverflowError, math.ldexp, 1., 1000000)

        self.assertRaises(OverflowError, math.ldexp, -1., 1000000)

        self.assertEquals(math.ldexp(1., -1000000), 0.)

        self.assertEquals(math.ldexp(-1., -1000000), -0.)

        self.assertEquals(math.ldexp(INF, 30), INF)

        self.assertEquals(math.ldexp(NINF, -213), NINF)

        self.assert_(math.isnan(math.ldexp(NAN, 0)))

        # large second argument

        for n in [10**5, 10L**5, 10**10, 10L**10, 10**20, 10**40]:

            self.assertEquals(math.ldexp(INF, -n), INF)

            self.assertEquals(math.ldexp(NINF, -n), NINF)

            self.assertEquals(math.ldexp(1., -n), 0.)

            self.assertEquals(math.ldexp(-1., -n), -0.)

            self.assertEquals(math.ldexp(0., -n), 0.)

            self.assertEquals(math.ldexp(-0., -n), -0.)

            self.assert_(math.isnan(math.ldexp(NAN, -n)))

            self.assertRaises(OverflowError, math.ldexp, 1., n)

            self.assertRaises(OverflowError, math.ldexp, -1., n)

            self.assertEquals(math.ldexp(0., n), 0.)

            self.assertEquals(math.ldexp(-0., n), -0.)

            self.assertEquals(math.ldexp(INF, n), INF)

            self.assertEquals(math.ldexp(NINF, n), NINF)

            self.assert_(math.isnan(math.ldexp(NAN, n)))

    def testLog(self):

        self.assertRaises(TypeError, math.log)

        self.ftest('log(1/e)', math.log(1/math.e), -1)

        self.ftest('log(1)', math.log(1), 0)

        self.ftest('log(e)', math.log(math.e), 1)

        self.ftest('log(32,2)', math.log(32,2), 5)

        self.ftest('log(10**40, 10)', math.log(10**40, 10), 40)

        self.ftest('log(10**40, 10**20)', math.log(10**40, 10**20), 2)

        self.assertEquals(math.log(INF), INF)

        self.assertRaises(ValueError, math.log, NINF)

        self.assert_(math.isnan(math.log(NAN)))

    def testLog1p(self):

        self.assertRaises(TypeError, math.log1p)

        self.ftest('log1p(1/e -1)', math.log1p(1/math.e-1), -1)

        self.ftest('log1p(0)', math.log1p(0), 0)

        self.ftest('log1p(e-1)', math.log1p(math.e-1), 1)

        self.ftest('log1p(1)', math.log1p(1), math.log(2))

        self.assertEquals(math.log1p(INF), INF)

        self.assertRaises(ValueError, math.log1p, NINF)

        self.assert_(math.isnan(math.log1p(NAN)))

        n= 2**90

        self.assertAlmostEquals(math.log1p(n), 62.383246250395075)

        self.assertAlmostEquals(math.log1p(n), math.log1p(float(n)))