home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 July / maximum-cd-2011-07.iso / DiscContents / LibO_3.3.2_Win_x86_install_multi.exe / libreoffice1.cab / test_float.py < prev    next >
Encoding:
Python Source  |  2011-03-15  |  32.5 KB  |  751 lines
  1.  
  2. import unittest, struct
  3. import os
  4. from test import test_support
  5. import math
  6. from math import isinf, isnan, copysign, ldexp
  7. import operator
  8. import random, fractions
  9.  
  10. INF = float("inf")
  11. NAN = float("nan")
  12.  
  13. class GeneralFloatCases(unittest.TestCase):
  14.  
  15.     def test_float(self):
  16.         self.assertEqual(float(3.14), 3.14)
  17.         self.assertEqual(float(314), 314.0)
  18.         self.assertEqual(float(314L), 314.0)
  19.         self.assertEqual(float("  3.14  "), 3.14)
  20.         self.assertRaises(ValueError, float, "  0x3.1  ")
  21.         self.assertRaises(ValueError, float, "  -0x3.p-1  ")
  22.         self.assertRaises(ValueError, float, "  +0x3.p-1  ")
  23.         self.assertRaises(ValueError, float, "++3.14")
  24.         self.assertRaises(ValueError, float, "+-3.14")
  25.         self.assertRaises(ValueError, float, "-+3.14")
  26.         self.assertRaises(ValueError, float, "--3.14")
  27.         if test_support.have_unicode:
  28.             self.assertEqual(float(unicode("  3.14  ")), 3.14)
  29.             self.assertEqual(float(unicode("  \u0663.\u0661\u0664  ",'raw-unicode-escape')), 3.14)
  30.             # Implementation limitation in PyFloat_FromString()
  31.             self.assertRaises(ValueError, float, unicode("1"*10000))
  32.  
  33.     @test_support.run_with_locale('LC_NUMERIC', 'fr_FR', 'de_DE')
  34.     def test_float_with_comma(self):
  35.         # set locale to something that doesn't use '.' for the decimal point
  36.         # float must not accept the locale specific decimal point but
  37.         # it still has to accept the normal python syntac
  38.         import locale
  39.         if not locale.localeconv()['decimal_point'] == ',':
  40.             return
  41.  
  42.         self.assertEqual(float("  3.14  "), 3.14)
  43.         self.assertEqual(float("+3.14  "), 3.14)
  44.         self.assertEqual(float("-3.14  "), -3.14)
  45.         self.assertEqual(float(".14  "), .14)
  46.         self.assertEqual(float("3.  "), 3.0)
  47.         self.assertEqual(float("3.e3  "), 3000.0)
  48.         self.assertEqual(float("3.2e3  "), 3200.0)
  49.         self.assertEqual(float("2.5e-1  "), 0.25)
  50.         self.assertEqual(float("5e-1"), 0.5)
  51.         self.assertRaises(ValueError, float, "  3,14  ")
  52.         self.assertRaises(ValueError, float, "  +3,14  ")
  53.         self.assertRaises(ValueError, float, "  -3,14  ")
  54.         self.assertRaises(ValueError, float, "  0x3.1  ")
  55.         self.assertRaises(ValueError, float, "  -0x3.p-1  ")
  56.         self.assertRaises(ValueError, float, "  +0x3.p-1  ")
  57.         self.assertEqual(float("  25.e-1  "), 2.5)
  58.         self.assertEqual(test_support.fcmp(float("  .25e-1  "), .025), 0)
  59.  
  60.     def test_floatconversion(self):
  61.         # Make sure that calls to __float__() work properly
  62.         class Foo0:
  63.             def __float__(self):
  64.                 return 42.
  65.  
  66.         class Foo1(object):
  67.             def __float__(self):
  68.                 return 42.
  69.  
  70.         class Foo2(float):
  71.             def __float__(self):
  72.                 return 42.
  73.  
  74.         class Foo3(float):
  75.             def __new__(cls, value=0.):
  76.                 return float.__new__(cls, 2*value)
  77.  
  78.             def __float__(self):
  79.                 return self
  80.  
  81.         class Foo4(float):
  82.             def __float__(self):
  83.                 return 42
  84.  
  85.         self.assertAlmostEqual(float(Foo0()), 42.)
  86.         self.assertAlmostEqual(float(Foo1()), 42.)
  87.         self.assertAlmostEqual(float(Foo2()), 42.)
  88.         self.assertAlmostEqual(float(Foo3(21)), 42.)
  89.         self.assertRaises(TypeError, float, Foo4(42))
  90.  
  91.     def test_floatasratio(self):
  92.         for f, ratio in [
  93.                 (0.875, (7, 8)),
  94.                 (-0.875, (-7, 8)),
  95.                 (0.0, (0, 1)),
  96.                 (11.5, (23, 2)),
  97.             ]:
  98.             self.assertEqual(f.as_integer_ratio(), ratio)
  99.  
  100.         for i in range(10000):
  101.             f = random.random()
  102.             f *= 10 ** random.randint(-100, 100)
  103.             n, d = f.as_integer_ratio()
  104.             self.assertEqual(float(n).__truediv__(d), f)
  105.  
  106.         R = fractions.Fraction
  107.         self.assertEqual(R(0, 1),
  108.                          R(*float(0.0).as_integer_ratio()))
  109.         self.assertEqual(R(5, 2),
  110.                          R(*float(2.5).as_integer_ratio()))
  111.         self.assertEqual(R(1, 2),
  112.                          R(*float(0.5).as_integer_ratio()))
  113.         self.assertEqual(R(4728779608739021, 2251799813685248),
  114.                          R(*float(2.1).as_integer_ratio()))
  115.         self.assertEqual(R(-4728779608739021, 2251799813685248),
  116.                          R(*float(-2.1).as_integer_ratio()))
  117.         self.assertEqual(R(-2100, 1),
  118.                          R(*float(-2100.0).as_integer_ratio()))
  119.  
  120.         self.assertRaises(OverflowError, float('inf').as_integer_ratio)
  121.         self.assertRaises(OverflowError, float('-inf').as_integer_ratio)
  122.         self.assertRaises(ValueError, float('nan').as_integer_ratio)
  123.  
  124. class FormatFunctionsTestCase(unittest.TestCase):
  125.  
  126.     def setUp(self):
  127.         self.save_formats = {'double':float.__getformat__('double'),
  128.                              'float':float.__getformat__('float')}
  129.  
  130.     def tearDown(self):
  131.         float.__setformat__('double', self.save_formats['double'])
  132.         float.__setformat__('float', self.save_formats['float'])
  133.  
  134.     def test_getformat(self):
  135.         self.assert_(float.__getformat__('double') in
  136.                      ['unknown', 'IEEE, big-endian', 'IEEE, little-endian'])
  137.         self.assert_(float.__getformat__('float') in
  138.                      ['unknown', 'IEEE, big-endian', 'IEEE, little-endian'])
  139.         self.assertRaises(ValueError, float.__getformat__, 'chicken')
  140.         self.assertRaises(TypeError, float.__getformat__, 1)
  141.  
  142.     def test_setformat(self):
  143.         for t in 'double', 'float':
  144.             float.__setformat__(t, 'unknown')
  145.             if self.save_formats[t] == 'IEEE, big-endian':
  146.                 self.assertRaises(ValueError, float.__setformat__,
  147.                                   t, 'IEEE, little-endian')
  148.             elif self.save_formats[t] == 'IEEE, little-endian':
  149.                 self.assertRaises(ValueError, float.__setformat__,
  150.                                   t, 'IEEE, big-endian')
  151.             else:
  152.                 self.assertRaises(ValueError, float.__setformat__,
  153.                                   t, 'IEEE, big-endian')
  154.                 self.assertRaises(ValueError, float.__setformat__,
  155.                                   t, 'IEEE, little-endian')
  156.             self.assertRaises(ValueError, float.__setformat__,
  157.                               t, 'chicken')
  158.         self.assertRaises(ValueError, float.__setformat__,
  159.                           'chicken', 'unknown')
  160.  
  161. BE_DOUBLE_INF = '\x7f\xf0\x00\x00\x00\x00\x00\x00'
  162. LE_DOUBLE_INF = ''.join(reversed(BE_DOUBLE_INF))
  163. BE_DOUBLE_NAN = '\x7f\xf8\x00\x00\x00\x00\x00\x00'
  164. LE_DOUBLE_NAN = ''.join(reversed(BE_DOUBLE_NAN))
  165.  
  166. BE_FLOAT_INF = '\x7f\x80\x00\x00'
  167. LE_FLOAT_INF = ''.join(reversed(BE_FLOAT_INF))
  168. BE_FLOAT_NAN = '\x7f\xc0\x00\x00'
  169. LE_FLOAT_NAN = ''.join(reversed(BE_FLOAT_NAN))
  170.  
  171. # on non-IEEE platforms, attempting to unpack a bit pattern
  172. # representing an infinity or a NaN should raise an exception.
  173.  
  174. class UnknownFormatTestCase(unittest.TestCase):
  175.     def setUp(self):
  176.         self.save_formats = {'double':float.__getformat__('double'),
  177.                              'float':float.__getformat__('float')}
  178.         float.__setformat__('double', 'unknown')
  179.         float.__setformat__('float', 'unknown')
  180.  
  181.     def tearDown(self):
  182.         float.__setformat__('double', self.save_formats['double'])
  183.         float.__setformat__('float', self.save_formats['float'])
  184.  
  185.     def test_double_specials_dont_unpack(self):
  186.         for fmt, data in [('>d', BE_DOUBLE_INF),
  187.                           ('>d', BE_DOUBLE_NAN),
  188.                           ('<d', LE_DOUBLE_INF),
  189.                           ('<d', LE_DOUBLE_NAN)]:
  190.             self.assertRaises(ValueError, struct.unpack, fmt, data)
  191.  
  192.     def test_float_specials_dont_unpack(self):
  193.         for fmt, data in [('>f', BE_FLOAT_INF),
  194.                           ('>f', BE_FLOAT_NAN),
  195.                           ('<f', LE_FLOAT_INF),
  196.                           ('<f', LE_FLOAT_NAN)]:
  197.             self.assertRaises(ValueError, struct.unpack, fmt, data)
  198.  
  199.  
  200. # on an IEEE platform, all we guarantee is that bit patterns
  201. # representing infinities or NaNs do not raise an exception; all else
  202. # is accident (today).
  203. # let's also try to guarantee that -0.0 and 0.0 don't get confused.
  204.  
  205. class IEEEFormatTestCase(unittest.TestCase):
  206.     if float.__getformat__("double").startswith("IEEE"):
  207.         def test_double_specials_do_unpack(self):
  208.             for fmt, data in [('>d', BE_DOUBLE_INF),
  209.                               ('>d', BE_DOUBLE_NAN),
  210.                               ('<d', LE_DOUBLE_INF),
  211.                               ('<d', LE_DOUBLE_NAN)]:
  212.                 struct.unpack(fmt, data)
  213.  
  214.     if float.__getformat__("float").startswith("IEEE"):
  215.         def test_float_specials_do_unpack(self):
  216.             for fmt, data in [('>f', BE_FLOAT_INF),
  217.                               ('>f', BE_FLOAT_NAN),
  218.                               ('<f', LE_FLOAT_INF),
  219.                               ('<f', LE_FLOAT_NAN)]:
  220.                 struct.unpack(fmt, data)
  221.  
  222.     if float.__getformat__("double").startswith("IEEE"):
  223.         def test_negative_zero(self):
  224.             import math
  225.             def pos_pos():
  226.                 return 0.0, math.atan2(0.0, -1)
  227.             def pos_neg():
  228.                 return 0.0, math.atan2(-0.0, -1)
  229.             def neg_pos():
  230.                 return -0.0, math.atan2(0.0, -1)
  231.             def neg_neg():
  232.                 return -0.0, math.atan2(-0.0, -1)
  233.             self.assertEquals(pos_pos(), neg_pos())
  234.             self.assertEquals(pos_neg(), neg_neg())
  235.  
  236.     if float.__getformat__("double").startswith("IEEE"):
  237.         def test_underflow_sign(self):
  238.             import math
  239.             # check that -1e-1000 gives -0.0, not 0.0
  240.             self.assertEquals(math.atan2(-1e-1000, -1), math.atan2(-0.0, -1))
  241.             self.assertEquals(math.atan2(float('-1e-1000'), -1),
  242.                               math.atan2(-0.0, -1))
  243.  
  244. class ReprTestCase(unittest.TestCase):
  245.     def test_repr(self):
  246.         floats_file = open(os.path.join(os.path.split(__file__)[0],
  247.                            'floating_points.txt'))
  248.         for line in floats_file:
  249.             line = line.strip()
  250.             if not line or line.startswith('#'):
  251.                 continue
  252.             v = eval(line)
  253.             self.assertEqual(v, eval(repr(v)))
  254.         floats_file.close()
  255.  
  256. # Beginning with Python 2.6 float has cross platform compatible
  257. # ways to create and represent inf and nan
  258. class InfNanTest(unittest.TestCase):
  259.     def test_inf_from_str(self):
  260.         self.assert_(isinf(float("inf")))
  261.         self.assert_(isinf(float("+inf")))
  262.         self.assert_(isinf(float("-inf")))
  263.         self.assert_(isinf(float("infinity")))
  264.         self.assert_(isinf(float("+infinity")))
  265.         self.assert_(isinf(float("-infinity")))
  266.  
  267.         self.assertEqual(repr(float("inf")), "inf")
  268.         self.assertEqual(repr(float("+inf")), "inf")
  269.         self.assertEqual(repr(float("-inf")), "-inf")
  270.         self.assertEqual(repr(float("infinity")), "inf")
  271.         self.assertEqual(repr(float("+infinity")), "inf")
  272.         self.assertEqual(repr(float("-infinity")), "-inf")
  273.  
  274.         self.assertEqual(repr(float("INF")), "inf")
  275.         self.assertEqual(repr(float("+Inf")), "inf")
  276.         self.assertEqual(repr(float("-iNF")), "-inf")
  277.         self.assertEqual(repr(float("Infinity")), "inf")
  278.         self.assertEqual(repr(float("+iNfInItY")), "inf")
  279.         self.assertEqual(repr(float("-INFINITY")), "-inf")
  280.  
  281.         self.assertEqual(str(float("inf")), "inf")
  282.         self.assertEqual(str(float("+inf")), "inf")
  283.         self.assertEqual(str(float("-inf")), "-inf")
  284.         self.assertEqual(str(float("infinity")), "inf")
  285.         self.assertEqual(str(float("+infinity")), "inf")
  286.         self.assertEqual(str(float("-infinity")), "-inf")
  287.  
  288.         self.assertRaises(ValueError, float, "info")
  289.         self.assertRaises(ValueError, float, "+info")
  290.         self.assertRaises(ValueError, float, "-info")
  291.         self.assertRaises(ValueError, float, "in")
  292.         self.assertRaises(ValueError, float, "+in")
  293.         self.assertRaises(ValueError, float, "-in")
  294.         self.assertRaises(ValueError, float, "infinit")
  295.         self.assertRaises(ValueError, float, "+Infin")
  296.         self.assertRaises(ValueError, float, "-INFI")
  297.         self.assertRaises(ValueError, float, "infinitys")
  298.  
  299.     def test_inf_as_str(self):
  300.         self.assertEqual(repr(1e300 * 1e300), "inf")
  301.         self.assertEqual(repr(-1e300 * 1e300), "-inf")
  302.  
  303.         self.assertEqual(str(1e300 * 1e300), "inf")
  304.         self.assertEqual(str(-1e300 * 1e300), "-inf")
  305.  
  306.     def test_nan_from_str(self):
  307.         self.assert_(isnan(float("nan")))
  308.         self.assert_(isnan(float("+nan")))
  309.         self.assert_(isnan(float("-nan")))
  310.  
  311.         self.assertEqual(repr(float("nan")), "nan")
  312.         self.assertEqual(repr(float("+nan")), "nan")
  313.         self.assertEqual(repr(float("-nan")), "nan")
  314.  
  315.         self.assertEqual(repr(float("NAN")), "nan")
  316.         self.assertEqual(repr(float("+NAn")), "nan")
  317.         self.assertEqual(repr(float("-NaN")), "nan")
  318.  
  319.         self.assertEqual(str(float("nan")), "nan")
  320.         self.assertEqual(str(float("+nan")), "nan")
  321.         self.assertEqual(str(float("-nan")), "nan")
  322.  
  323.         self.assertRaises(ValueError, float, "nana")
  324.         self.assertRaises(ValueError, float, "+nana")
  325.         self.assertRaises(ValueError, float, "-nana")
  326.         self.assertRaises(ValueError, float, "na")
  327.         self.assertRaises(ValueError, float, "+na")
  328.         self.assertRaises(ValueError, float, "-na")
  329.  
  330.     def test_nan_as_str(self):
  331.         self.assertEqual(repr(1e300 * 1e300 * 0), "nan")
  332.         self.assertEqual(repr(-1e300 * 1e300 * 0), "nan")
  333.  
  334.         self.assertEqual(str(1e300 * 1e300 * 0), "nan")
  335.         self.assertEqual(str(-1e300 * 1e300 * 0), "nan")
  336.  
  337.     def notest_float_nan(self):
  338.         self.assert_(NAN.is_nan())
  339.         self.failIf(INF.is_nan())
  340.         self.failIf((0.).is_nan())
  341.  
  342.     def notest_float_inf(self):
  343.         self.assert_(INF.is_inf())
  344.         self.failIf(NAN.is_inf())
  345.         self.failIf((0.).is_inf())
  346.  
  347. fromHex = float.fromhex
  348. toHex = float.hex
  349. class HexFloatTestCase(unittest.TestCase):
  350.     MAX = fromHex('0x.fffffffffffff8p+1024')  # max normal
  351.     MIN = fromHex('0x1p-1022')                # min normal
  352.     TINY = fromHex('0x0.0000000000001p-1022') # min subnormal
  353.     EPS = fromHex('0x0.0000000000001p0') # diff between 1.0 and next float up
  354.  
  355.     def identical(self, x, y):
  356.         # check that floats x and y are identical, or that both
  357.         # are NaNs
  358.         if isnan(x) or isnan(y):
  359.             if isnan(x) == isnan(y):
  360.                 return
  361.         elif x == y and (x != 0.0 or copysign(1.0, x) == copysign(1.0, y)):
  362.             return
  363.         self.fail('%r not identical to %r' % (x, y))
  364.  
  365.     def test_ends(self):
  366.         self.identical(self.MIN, ldexp(1.0, -1022))
  367.         self.identical(self.TINY, ldexp(1.0, -1074))
  368.         self.identical(self.EPS, ldexp(1.0, -52))
  369.         self.identical(self.MAX, 2.*(ldexp(1.0, 1023) - ldexp(1.0, 970)))
  370.  
  371.     def test_invalid_inputs(self):
  372.         invalid_inputs = [
  373.             'infi',   # misspelt infinities and nans
  374.             '-Infinit',
  375.             '++inf',
  376.             '-+Inf',
  377.             '--nan',
  378.             '+-NaN',
  379.             'snan',
  380.             'NaNs',
  381.             'nna',
  382.             '0xnan',
  383.             '',
  384.             ' ',
  385.             'x1.0p0',
  386.             '0xX1.0p0',
  387.             '+ 0x1.0p0', # internal whitespace
  388.             '- 0x1.0p0',
  389.             '0 x1.0p0',
  390.             '0x 1.0p0',
  391.             '0x1 2.0p0',
  392.             '+0x1 .0p0',
  393.             '0x1. 0p0',
  394.             '-0x1.0 1p0',
  395.             '-0x1.0 p0',
  396.             '+0x1.0p +0',
  397.             '0x1.0p -0',
  398.             '0x1.0p 0',
  399.             '+0x1.0p+ 0',
  400.             '-0x1.0p- 0',
  401.             '++0x1.0p-0', # double signs
  402.             '--0x1.0p0',
  403.             '+-0x1.0p+0',
  404.             '-+0x1.0p0',
  405.             '0x1.0p++0',
  406.             '+0x1.0p+-0',
  407.             '-0x1.0p-+0',
  408.             '0x1.0p--0',
  409.             '0x1.0.p0',
  410.             '0x.p0', # no hex digits before or after point
  411.             '0x1,p0', # wrong decimal point character
  412.             '0x1pa',
  413.             u'0x1p\uff10',  # fullwidth Unicode digits
  414.             u'\uff10x1p0',
  415.             u'0x\uff11p0',
  416.             u'0x1.\uff10p0',
  417.             '0x1p0 \n 0x2p0',
  418.             '0x1p0\0 0x1p0',  # embedded null byte is not end of string
  419.             ]
  420.         for x in invalid_inputs:
  421.             try:
  422.                 result = fromHex(x)
  423.             except ValueError:
  424.                 pass
  425.             else:
  426.                 self.fail('Expected float.fromhex(%r) to raise ValueError; '
  427.                           'got %r instead' % (x, result))
  428.  
  429.  
  430.     def test_from_hex(self):
  431.         MIN = self.MIN;
  432.         MAX = self.MAX;
  433.         TINY = self.TINY;
  434.         EPS = self.EPS;
  435.  
  436.         # two spellings of infinity, with optional signs; case-insensitive
  437.         self.identical(fromHex('inf'), INF)
  438.         self.identical(fromHex('+Inf'), INF)
  439.         self.identical(fromHex('-INF'), -INF)
  440.         self.identical(fromHex('iNf'), INF)
  441.         self.identical(fromHex('Infinity'), INF)
  442.         self.identical(fromHex('+INFINITY'), INF)
  443.         self.identical(fromHex('-infinity'), -INF)
  444.         self.identical(fromHex('-iNFiNitY'), -INF)
  445.  
  446.         # nans with optional sign; case insensitive
  447.         self.identical(fromHex('nan'), NAN)
  448.         self.identical(fromHex('+NaN'), NAN)
  449.         self.identical(fromHex('-NaN'), NAN)
  450.         self.identical(fromHex('-nAN'), NAN)
  451.  
  452.         # variations in input format
  453.         self.identical(fromHex('1'), 1.0)
  454.         self.identical(fromHex('+1'), 1.0)
  455.         self.identical(fromHex('1.'), 1.0)
  456.         self.identical(fromHex('1.0'), 1.0)
  457.         self.identical(fromHex('1.0p0'), 1.0)
  458.         self.identical(fromHex('01'), 1.0)
  459.         self.identical(fromHex('01.'), 1.0)
  460.         self.identical(fromHex('0x1'), 1.0)
  461.         self.identical(fromHex('0x1.'), 1.0)
  462.         self.identical(fromHex('0x1.0'), 1.0)
  463.         self.identical(fromHex('+0x1.0'), 1.0)
  464.         self.identical(fromHex('0x1p0'), 1.0)
  465.         self.identical(fromHex('0X1p0'), 1.0)
  466.         self.identical(fromHex('0X1P0'), 1.0)
  467.         self.identical(fromHex('0x1P0'), 1.0)
  468.         self.identical(fromHex('0x1.p0'), 1.0)
  469.         self.identical(fromHex('0x1.0p0'), 1.0)
  470.         self.identical(fromHex('0x.1p4'), 1.0)
  471.         self.identical(fromHex('0x.1p04'), 1.0)
  472.         self.identical(fromHex('0x.1p004'), 1.0)
  473.         self.identical(fromHex('0x1p+0'), 1.0)
  474.         self.identical(fromHex('0x1P-0'), 1.0)
  475.         self.identical(fromHex('+0x1p0'), 1.0)
  476.         self.identical(fromHex('0x01p0'), 1.0)
  477.         self.identical(fromHex('0x1p00'), 1.0)
  478.         self.identical(fromHex(u'0x1p0'), 1.0)
  479.         self.identical(fromHex(' 0x1p0 '), 1.0)
  480.         self.identical(fromHex('\n 0x1p0'), 1.0)
  481.         self.identical(fromHex('0x1p0 \t'), 1.0)
  482.         self.identical(fromHex('0xap0'), 10.0)
  483.         self.identical(fromHex('0xAp0'), 10.0)
  484.         self.identical(fromHex('0xaP0'), 10.0)
  485.         self.identical(fromHex('0xAP0'), 10.0)
  486.         self.identical(fromHex('0xbep0'), 190.0)
  487.         self.identical(fromHex('0xBep0'), 190.0)
  488.         self.identical(fromHex('0xbEp0'), 190.0)
  489.         self.identical(fromHex('0XBE0P-4'), 190.0)
  490.         self.identical(fromHex('0xBEp0'), 190.0)
  491.         self.identical(fromHex('0xB.Ep4'), 190.0)
  492.         self.identical(fromHex('0x.BEp8'), 190.0)
  493.         self.identical(fromHex('0x.0BEp12'), 190.0)
  494.  
  495.         # moving the point around
  496.         pi = fromHex('0x1.921fb54442d18p1')
  497.         self.identical(fromHex('0x.006487ed5110b46p11'), pi)
  498.         self.identical(fromHex('0x.00c90fdaa22168cp10'), pi)
  499.         self.identical(fromHex('0x.01921fb54442d18p9'), pi)
  500.         self.identical(fromHex('0x.03243f6a8885a3p8'), pi)
  501.         self.identical(fromHex('0x.06487ed5110b46p7'), pi)
  502.         self.identical(fromHex('0x.0c90fdaa22168cp6'), pi)
  503.         self.identical(fromHex('0x.1921fb54442d18p5'), pi)
  504.         self.identical(fromHex('0x.3243f6a8885a3p4'), pi)
  505.         self.identical(fromHex('0x.6487ed5110b46p3'), pi)
  506.         self.identical(fromHex('0x.c90fdaa22168cp2'), pi)
  507.         self.identical(fromHex('0x1.921fb54442d18p1'), pi)
  508.         self.identical(fromHex('0x3.243f6a8885a3p0'), pi)
  509.         self.identical(fromHex('0x6.487ed5110b46p-1'), pi)
  510.         self.identical(fromHex('0xc.90fdaa22168cp-2'), pi)
  511.         self.identical(fromHex('0x19.21fb54442d18p-3'), pi)
  512.         self.identical(fromHex('0x32.43f6a8885a3p-4'), pi)
  513.         self.identical(fromHex('0x64.87ed5110b46p-5'), pi)
  514.         self.identical(fromHex('0xc9.0fdaa22168cp-6'), pi)
  515.         self.identical(fromHex('0x192.1fb54442d18p-7'), pi)
  516.         self.identical(fromHex('0x324.3f6a8885a3p-8'), pi)
  517.         self.identical(fromHex('0x648.7ed5110b46p-9'), pi)
  518.         self.identical(fromHex('0xc90.fdaa22168cp-10'), pi)
  519.         self.identical(fromHex('0x1921.fb54442d18p-11'), pi)
  520.         # ...
  521.         self.identical(fromHex('0x1921fb54442d1.8p-47'), pi)
  522.         self.identical(fromHex('0x3243f6a8885a3p-48'), pi)
  523.         self.identical(fromHex('0x6487ed5110b46p-49'), pi)
  524.         self.identical(fromHex('0xc90fdaa22168cp-50'), pi)
  525.         self.identical(fromHex('0x1921fb54442d18p-51'), pi)
  526.         self.identical(fromHex('0x3243f6a8885a30p-52'), pi)
  527.         self.identical(fromHex('0x6487ed5110b460p-53'), pi)
  528.         self.identical(fromHex('0xc90fdaa22168c0p-54'), pi)
  529.         self.identical(fromHex('0x1921fb54442d180p-55'), pi)
  530.  
  531.  
  532.         # results that should overflow...
  533.         self.assertRaises(OverflowError, fromHex, '-0x1p1024')
  534.         self.assertRaises(OverflowError, fromHex, '0x1p+1025')
  535.         self.assertRaises(OverflowError, fromHex, '+0X1p1030')
  536.         self.assertRaises(OverflowError, fromHex, '-0x1p+1100')
  537.         self.assertRaises(OverflowError, fromHex, '0X1p123456789123456789')
  538.         self.assertRaises(OverflowError, fromHex, '+0X.8p+1025')
  539.         self.assertRaises(OverflowError, fromHex, '+0x0.8p1025')
  540.         self.assertRaises(OverflowError, fromHex, '-0x0.4p1026')
  541.         self.assertRaises(OverflowError, fromHex, '0X2p+1023')
  542.         self.assertRaises(OverflowError, fromHex, '0x2.p1023')
  543.         self.assertRaises(OverflowError, fromHex, '-0x2.0p+1023')
  544.         self.assertRaises(OverflowError, fromHex, '+0X4p+1022')
  545.         self.assertRaises(OverflowError, fromHex, '0x1.ffffffffffffffp+1023')
  546.         self.assertRaises(OverflowError, fromHex, '-0X1.fffffffffffff9p1023')
  547.         self.assertRaises(OverflowError, fromHex, '0X1.fffffffffffff8p1023')
  548.         self.assertRaises(OverflowError, fromHex, '+0x3.fffffffffffffp1022')
  549.         self.assertRaises(OverflowError, fromHex, '0x3fffffffffffffp+970')
  550.         self.assertRaises(OverflowError, fromHex, '0x10000000000000000p960')
  551.         self.assertRaises(OverflowError, fromHex, '-0Xffffffffffffffffp960')
  552.  
  553.         # ...and those that round to +-max float
  554.         self.identical(fromHex('+0x1.fffffffffffffp+1023'), MAX)
  555.         self.identical(fromHex('-0X1.fffffffffffff7p1023'), -MAX)
  556.         self.identical(fromHex('0X1.fffffffffffff7fffffffffffffp1023'), MAX)
  557.  
  558.         # zeros
  559.         self.identical(fromHex('0x0p0'), 0.0)
  560.         self.identical(fromHex('0x0p1000'), 0.0)
  561.         self.identical(fromHex('-0x0p1023'), -0.0)
  562.         self.identical(fromHex('0X0p1024'), 0.0)
  563.         self.identical(fromHex('-0x0p1025'), -0.0)
  564.         self.identical(fromHex('0X0p2000'), 0.0)
  565.         self.identical(fromHex('0x0p123456789123456789'), 0.0)
  566.         self.identical(fromHex('-0X0p-0'), -0.0)
  567.         self.identical(fromHex('-0X0p-1000'), -0.0)
  568.         self.identical(fromHex('0x0p-1023'), 0.0)
  569.         self.identical(fromHex('-0X0p-1024'), -0.0)
  570.         self.identical(fromHex('-0x0p-1025'), -0.0)
  571.         self.identical(fromHex('-0x0p-1072'), -0.0)
  572.         self.identical(fromHex('0X0p-1073'), 0.0)
  573.         self.identical(fromHex('-0x0p-1074'), -0.0)
  574.         self.identical(fromHex('0x0p-1075'), 0.0)
  575.         self.identical(fromHex('0X0p-1076'), 0.0)
  576.         self.identical(fromHex('-0X0p-2000'), -0.0)
  577.         self.identical(fromHex('-0x0p-123456789123456789'), -0.0)
  578.  
  579.         # values that should underflow to 0
  580.         self.identical(fromHex('0X1p-1075'), 0.0)
  581.         self.identical(fromHex('-0X1p-1075'), -0.0)
  582.         self.identical(fromHex('-0x1p-123456789123456789'), -0.0)
  583.         self.identical(fromHex('0x1.00000000000000001p-1075'), TINY)
  584.         self.identical(fromHex('-0x1.1p-1075'), -TINY)
  585.         self.identical(fromHex('0x1.fffffffffffffffffp-1075'), TINY)
  586.  
  587.         # check round-half-even is working correctly near 0 ...
  588.         self.identical(fromHex('0x1p-1076'), 0.0)
  589.         self.identical(fromHex('0X2p-1076'), 0.0)
  590.         self.identical(fromHex('0X3p-1076'), TINY)
  591.         self.identical(fromHex('0x4p-1076'), TINY)
  592.         self.identical(fromHex('0X5p-1076'), TINY)
  593.         self.identical(fromHex('0X6p-1076'), 2*TINY)
  594.         self.identical(fromHex('0x7p-1076'), 2*TINY)
  595.         self.identical(fromHex('0X8p-1076'), 2*TINY)
  596.         self.identical(fromHex('0X9p-1076'), 2*TINY)
  597.         self.identical(fromHex('0xap-1076'), 2*TINY)
  598.         self.identical(fromHex('0Xbp-1076'), 3*TINY)
  599.         self.identical(fromHex('0xcp-1076'), 3*TINY)
  600.         self.identical(fromHex('0Xdp-1076'), 3*TINY)
  601.         self.identical(fromHex('0Xep-1076'), 4*TINY)
  602.         self.identical(fromHex('0xfp-1076'), 4*TINY)
  603.         self.identical(fromHex('0x10p-1076'), 4*TINY)
  604.         self.identical(fromHex('-0x1p-1076'), -0.0)
  605.         self.identical(fromHex('-0X2p-1076'), -0.0)
  606.         self.identical(fromHex('-0x3p-1076'), -TINY)
  607.         self.identical(fromHex('-0X4p-1076'), -TINY)
  608.         self.identical(fromHex('-0x5p-1076'), -TINY)
  609.         self.identical(fromHex('-0x6p-1076'), -2*TINY)
  610.         self.identical(fromHex('-0X7p-1076'), -2*TINY)
  611.         self.identical(fromHex('-0X8p-1076'), -2*TINY)
  612.         self.identical(fromHex('-0X9p-1076'), -2*TINY)
  613.         self.identical(fromHex('-0Xap-1076'), -2*TINY)
  614.         self.identical(fromHex('-0xbp-1076'), -3*TINY)
  615.         self.identical(fromHex('-0xcp-1076'), -3*TINY)
  616.         self.identical(fromHex('-0Xdp-1076'), -3*TINY)
  617.         self.identical(fromHex('-0xep-1076'), -4*TINY)
  618.         self.identical(fromHex('-0Xfp-1076'), -4*TINY)
  619.         self.identical(fromHex('-0X10p-1076'), -4*TINY)
  620.  
  621.         # ... and near MIN ...
  622.         self.identical(fromHex('0x0.ffffffffffffd6p-1022'), MIN-3*TINY)
  623.         self.identical(fromHex('0x0.ffffffffffffd8p-1022'), MIN-2*TINY)
  624.         self.identical(fromHex('0x0.ffffffffffffdap-1022'), MIN-2*TINY)
  625.         self.identical(fromHex('0x0.ffffffffffffdcp-1022'), MIN-2*TINY)
  626.         self.identical(fromHex('0x0.ffffffffffffdep-1022'), MIN-2*TINY)
  627.         self.identical(fromHex('0x0.ffffffffffffe0p-1022'), MIN-2*TINY)
  628.         self.identical(fromHex('0x0.ffffffffffffe2p-1022'), MIN-2*TINY)
  629.         self.identical(fromHex('0x0.ffffffffffffe4p-1022'), MIN-2*TINY)
  630.         self.identical(fromHex('0x0.ffffffffffffe6p-1022'), MIN-2*TINY)
  631.         self.identical(fromHex('0x0.ffffffffffffe8p-1022'), MIN-2*TINY)
  632.         self.identical(fromHex('0x0.ffffffffffffeap-1022'), MIN-TINY)
  633.         self.identical(fromHex('0x0.ffffffffffffecp-1022'), MIN-TINY)
  634.         self.identical(fromHex('0x0.ffffffffffffeep-1022'), MIN-TINY)
  635.         self.identical(fromHex('0x0.fffffffffffff0p-1022'), MIN-TINY)
  636.         self.identical(fromHex('0x0.fffffffffffff2p-1022'), MIN-TINY)
  637.         self.identical(fromHex('0x0.fffffffffffff4p-1022'), MIN-TINY)
  638.         self.identical(fromHex('0x0.fffffffffffff6p-1022'), MIN-TINY)
  639.         self.identical(fromHex('0x0.fffffffffffff8p-1022'), MIN)
  640.         self.identical(fromHex('0x0.fffffffffffffap-1022'), MIN)
  641.         self.identical(fromHex('0x0.fffffffffffffcp-1022'), MIN)
  642.         self.identical(fromHex('0x0.fffffffffffffep-1022'), MIN)
  643.         self.identical(fromHex('0x1.00000000000000p-1022'), MIN)
  644.         self.identical(fromHex('0x1.00000000000002p-1022'), MIN)
  645.         self.identical(fromHex('0x1.00000000000004p-1022'), MIN)
  646.         self.identical(fromHex('0x1.00000000000006p-1022'), MIN)
  647.         self.identical(fromHex('0x1.00000000000008p-1022'), MIN)
  648.         self.identical(fromHex('0x1.0000000000000ap-1022'), MIN+TINY)
  649.         self.identical(fromHex('0x1.0000000000000cp-1022'), MIN+TINY)
  650.         self.identical(fromHex('0x1.0000000000000ep-1022'), MIN+TINY)
  651.         self.identical(fromHex('0x1.00000000000010p-1022'), MIN+TINY)
  652.         self.identical(fromHex('0x1.00000000000012p-1022'), MIN+TINY)
  653.         self.identical(fromHex('0x1.00000000000014p-1022'), MIN+TINY)
  654.         self.identical(fromHex('0x1.00000000000016p-1022'), MIN+TINY)
  655.         self.identical(fromHex('0x1.00000000000018p-1022'), MIN+2*TINY)
  656.  
  657.         # ... and near 1.0.
  658.         self.identical(fromHex('0x0.fffffffffffff0p0'), 1.0-EPS)
  659.         self.identical(fromHex('0x0.fffffffffffff1p0'), 1.0-EPS)
  660.         self.identical(fromHex('0X0.fffffffffffff2p0'), 1.0-EPS)
  661.         self.identical(fromHex('0x0.fffffffffffff3p0'), 1.0-EPS)
  662.         self.identical(fromHex('0X0.fffffffffffff4p0'), 1.0-EPS)
  663.         self.identical(fromHex('0X0.fffffffffffff5p0'), 1.0-EPS/2)
  664.         self.identical(fromHex('0X0.fffffffffffff6p0'), 1.0-EPS/2)
  665.         self.identical(fromHex('0x0.fffffffffffff7p0'), 1.0-EPS/2)
  666.         self.identical(fromHex('0x0.fffffffffffff8p0'), 1.0-EPS/2)
  667.         self.identical(fromHex('0X0.fffffffffffff9p0'), 1.0-EPS/2)
  668.         self.identical(fromHex('0X0.fffffffffffffap0'), 1.0-EPS/2)
  669.         self.identical(fromHex('0x0.fffffffffffffbp0'), 1.0-EPS/2)
  670.         self.identical(fromHex('0X0.fffffffffffffcp0'), 1.0)
  671.         self.identical(fromHex('0x0.fffffffffffffdp0'), 1.0)
  672.         self.identical(fromHex('0X0.fffffffffffffep0'), 1.0)
  673.         self.identical(fromHex('0x0.ffffffffffffffp0'), 1.0)
  674.         self.identical(fromHex('0X1.00000000000000p0'), 1.0)
  675.         self.identical(fromHex('0X1.00000000000001p0'), 1.0)
  676.         self.identical(fromHex('0x1.00000000000002p0'), 1.0)
  677.         self.identical(fromHex('0X1.00000000000003p0'), 1.0)
  678.         self.identical(fromHex('0x1.00000000000004p0'), 1.0)
  679.         self.identical(fromHex('0X1.00000000000005p0'), 1.0)
  680.         self.identical(fromHex('0X1.00000000000006p0'), 1.0)
  681.         self.identical(fromHex('0X1.00000000000007p0'), 1.0)
  682.         self.identical(fromHex('0x1.00000000000007ffffffffffffffffffffp0'),
  683.                        1.0)
  684.         self.identical(fromHex('0x1.00000000000008p0'), 1.0)
  685.         self.identical(fromHex('0x1.00000000000008000000000000000001p0'),
  686.                        1+EPS)
  687.         self.identical(fromHex('0X1.00000000000009p0'), 1.0+EPS)
  688.         self.identical(fromHex('0x1.0000000000000ap0'), 1.0+EPS)
  689.         self.identical(fromHex('0x1.0000000000000bp0'), 1.0+EPS)
  690.         self.identical(fromHex('0X1.0000000000000cp0'), 1.0+EPS)
  691.         self.identical(fromHex('0x1.0000000000000dp0'), 1.0+EPS)
  692.         self.identical(fromHex('0x1.0000000000000ep0'), 1.0+EPS)
  693.         self.identical(fromHex('0X1.0000000000000fp0'), 1.0+EPS)
  694.         self.identical(fromHex('0x1.00000000000010p0'), 1.0+EPS)
  695.         self.identical(fromHex('0X1.00000000000011p0'), 1.0+EPS)
  696.         self.identical(fromHex('0x1.00000000000012p0'), 1.0+EPS)
  697.         self.identical(fromHex('0X1.00000000000013p0'), 1.0+EPS)
  698.         self.identical(fromHex('0X1.00000000000014p0'), 1.0+EPS)
  699.         self.identical(fromHex('0x1.00000000000015p0'), 1.0+EPS)
  700.         self.identical(fromHex('0x1.00000000000016p0'), 1.0+EPS)
  701.         self.identical(fromHex('0X1.00000000000017p0'), 1.0+EPS)
  702.         self.identical(fromHex('0x1.00000000000017ffffffffffffffffffffp0'),
  703.                        1.0+EPS)
  704.         self.identical(fromHex('0x1.00000000000018p0'), 1.0+2*EPS)
  705.         self.identical(fromHex('0X1.00000000000018000000000000000001p0'),
  706.                        1.0+2*EPS)
  707.         self.identical(fromHex('0x1.00000000000019p0'), 1.0+2*EPS)
  708.         self.identical(fromHex('0X1.0000000000001ap0'), 1.0+2*EPS)
  709.         self.identical(fromHex('0X1.0000000000001bp0'), 1.0+2*EPS)
  710.         self.identical(fromHex('0x1.0000000000001cp0'), 1.0+2*EPS)
  711.         self.identical(fromHex('0x1.0000000000001dp0'), 1.0+2*EPS)
  712.         self.identical(fromHex('0x1.0000000000001ep0'), 1.0+2*EPS)
  713.         self.identical(fromHex('0X1.0000000000001fp0'), 1.0+2*EPS)
  714.         self.identical(fromHex('0x1.00000000000020p0'), 1.0+2*EPS)
  715.  
  716.     def test_roundtrip(self):
  717.         def roundtrip(x):
  718.             return fromHex(toHex(x))
  719.  
  720.         for x in [NAN, INF, self.MAX, self.MIN, self.MIN-self.TINY, self.TINY, 0.0]:
  721.             self.identical(x, roundtrip(x))
  722.             self.identical(-x, roundtrip(-x))
  723.  
  724.         # fromHex(toHex(x)) should exactly recover x, for any non-NaN float x.
  725.         import random
  726.         for i in xrange(10000):
  727.             e = random.randrange(-1200, 1200)
  728.             m = random.random()
  729.             s = random.choice([1.0, -1.0])
  730.             try:
  731.                 x = s*ldexp(m, e)
  732.             except OverflowError:
  733.                 pass
  734.             else:
  735.                 self.identical(x, fromHex(toHex(x)))
  736.  
  737.  
  738. def test_main():
  739.     test_support.run_unittest(
  740.         GeneralFloatCases,
  741.         FormatFunctionsTestCase,
  742.         UnknownFormatTestCase,
  743.         IEEEFormatTestCase,
  744.         ReprTestCase,
  745.         InfNanTest,
  746.         HexFloatTestCase,
  747.         )
  748.  
  749. if __name__ == '__main__':
  750.     test_main()
  751.