mirror of https://github.com/python/cpython
1417 lines
62 KiB
Python
1417 lines
62 KiB
Python
|
|
import unittest, struct
|
|
import os
|
|
from test import test_support
|
|
import math
|
|
from math import isinf, isnan, copysign, ldexp
|
|
import operator
|
|
import random
|
|
import fractions
|
|
import sys
|
|
import re
|
|
|
|
INF = float("inf")
|
|
NAN = float("nan")
|
|
|
|
# decorator for skipping tests on non-IEEE 754 platforms
|
|
requires_IEEE_754 = unittest.skipUnless(
|
|
float.__getformat__("double").startswith("IEEE"),
|
|
"test requires IEEE 754 doubles")
|
|
|
|
#locate file with float format test values
|
|
test_dir = os.path.dirname(__file__) or os.curdir
|
|
format_testfile = os.path.join(test_dir, 'formatfloat_testcases.txt')
|
|
|
|
finite_decimal_parser = re.compile(r""" # A numeric string consists of:
|
|
(?P<sign>[-+])? # an optional sign, followed by
|
|
(?=\d|\.\d) # a number with at least one digit
|
|
(?P<int>\d*) # having a (possibly empty) integer part
|
|
(?:\.(?P<frac>\d*))? # followed by an optional fractional part
|
|
(?:E(?P<exp>[-+]?\d+))? # and an optional exponent
|
|
\Z
|
|
""", re.VERBOSE | re.IGNORECASE | re.UNICODE).match
|
|
|
|
# Pure Python version of correctly rounded string->float conversion.
|
|
# Avoids any use of floating-point by returning the result as a hex string.
|
|
def strtod(s, mant_dig=53, min_exp = -1021, max_exp = 1024):
|
|
"""Convert a finite decimal string to a hex string representing an
|
|
IEEE 754 binary64 float. Return 'inf' or '-inf' on overflow.
|
|
This function makes no use of floating-point arithmetic at any
|
|
stage."""
|
|
|
|
# parse string into a pair of integers 'a' and 'b' such that
|
|
# abs(decimal value) = a/b, and a boolean 'negative'.
|
|
m = finite_decimal_parser(s)
|
|
if m is None:
|
|
raise ValueError('invalid numeric string')
|
|
fraction = m.group('frac') or ''
|
|
intpart = int(m.group('int') + fraction)
|
|
exp = int(m.group('exp') or '0') - len(fraction)
|
|
negative = m.group('sign') == '-'
|
|
a, b = intpart*10**max(exp, 0), 10**max(0, -exp)
|
|
|
|
# quick return for zeros
|
|
if not a:
|
|
return '-0x0.0p+0' if negative else '0x0.0p+0'
|
|
|
|
# compute exponent e for result; may be one too small in the case
|
|
# that the rounded value of a/b lies in a different binade from a/b
|
|
d = a.bit_length() - b.bit_length()
|
|
d += (a >> d if d >= 0 else a << -d) >= b
|
|
e = max(d, min_exp) - mant_dig
|
|
|
|
# approximate a/b by number of the form q * 2**e; adjust e if necessary
|
|
a, b = a << max(-e, 0), b << max(e, 0)
|
|
q, r = divmod(a, b)
|
|
if 2*r > b or 2*r == b and q & 1:
|
|
q += 1
|
|
if q.bit_length() == mant_dig+1:
|
|
q //= 2
|
|
e += 1
|
|
|
|
# double check that (q, e) has the right form
|
|
assert q.bit_length() <= mant_dig and e >= min_exp - mant_dig
|
|
assert q.bit_length() == mant_dig or e == min_exp - mant_dig
|
|
|
|
# check for overflow and underflow
|
|
if e + q.bit_length() > max_exp:
|
|
return '-inf' if negative else 'inf'
|
|
if not q:
|
|
return '-0x0.0p+0' if negative else '0x0.0p+0'
|
|
|
|
# for hex representation, shift so # bits after point is a multiple of 4
|
|
hexdigs = 1 + (mant_dig-2)//4
|
|
shift = 3 - (mant_dig-2)%4
|
|
q, e = q << shift, e - shift
|
|
return '{}0x{:x}.{:0{}x}p{:+d}'.format(
|
|
'-' if negative else '',
|
|
q // 16**hexdigs,
|
|
q % 16**hexdigs,
|
|
hexdigs,
|
|
e + 4*hexdigs)
|
|
|
|
class GeneralFloatCases(unittest.TestCase):
|
|
|
|
def test_float(self):
|
|
self.assertEqual(float(3.14), 3.14)
|
|
self.assertEqual(float(314), 314.0)
|
|
self.assertEqual(float(314L), 314.0)
|
|
self.assertEqual(float(" 3.14 "), 3.14)
|
|
self.assertRaises(ValueError, float, " 0x3.1 ")
|
|
self.assertRaises(ValueError, float, " -0x3.p-1 ")
|
|
self.assertRaises(ValueError, float, " +0x3.p-1 ")
|
|
self.assertRaises(ValueError, float, "++3.14")
|
|
self.assertRaises(ValueError, float, "+-3.14")
|
|
self.assertRaises(ValueError, float, "-+3.14")
|
|
self.assertRaises(ValueError, float, "--3.14")
|
|
if test_support.have_unicode:
|
|
self.assertEqual(float(unicode(" 3.14 ")), 3.14)
|
|
self.assertEqual(float(unicode(" \u0663.\u0661\u0664 ",'raw-unicode-escape')), 3.14)
|
|
|
|
# extra long strings should no longer be a problem
|
|
# (in 2.6, long unicode inputs to float raised ValueError)
|
|
float('.' + '1'*1000)
|
|
float(unicode('.' + '1'*1000))
|
|
|
|
@test_support.run_with_locale('LC_NUMERIC', 'fr_FR', 'de_DE')
|
|
def test_float_with_comma(self):
|
|
# set locale to something that doesn't use '.' for the decimal point
|
|
# float must not accept the locale specific decimal point but
|
|
# it still has to accept the normal python syntac
|
|
import locale
|
|
if not locale.localeconv()['decimal_point'] == ',':
|
|
return
|
|
|
|
self.assertEqual(float(" 3.14 "), 3.14)
|
|
self.assertEqual(float("+3.14 "), 3.14)
|
|
self.assertEqual(float("-3.14 "), -3.14)
|
|
self.assertEqual(float(".14 "), .14)
|
|
self.assertEqual(float("3. "), 3.0)
|
|
self.assertEqual(float("3.e3 "), 3000.0)
|
|
self.assertEqual(float("3.2e3 "), 3200.0)
|
|
self.assertEqual(float("2.5e-1 "), 0.25)
|
|
self.assertEqual(float("5e-1"), 0.5)
|
|
self.assertRaises(ValueError, float, " 3,14 ")
|
|
self.assertRaises(ValueError, float, " +3,14 ")
|
|
self.assertRaises(ValueError, float, " -3,14 ")
|
|
self.assertRaises(ValueError, float, " 0x3.1 ")
|
|
self.assertRaises(ValueError, float, " -0x3.p-1 ")
|
|
self.assertRaises(ValueError, float, " +0x3.p-1 ")
|
|
self.assertEqual(float(" 25.e-1 "), 2.5)
|
|
self.assertEqual(test_support.fcmp(float(" .25e-1 "), .025), 0)
|
|
|
|
def test_floatconversion(self):
|
|
# Make sure that calls to __float__() work properly
|
|
class Foo0:
|
|
def __float__(self):
|
|
return 42.
|
|
|
|
class Foo1(object):
|
|
def __float__(self):
|
|
return 42.
|
|
|
|
class Foo2(float):
|
|
def __float__(self):
|
|
return 42.
|
|
|
|
class Foo3(float):
|
|
def __new__(cls, value=0.):
|
|
return float.__new__(cls, 2*value)
|
|
|
|
def __float__(self):
|
|
return self
|
|
|
|
class Foo4(float):
|
|
def __float__(self):
|
|
return 42
|
|
|
|
# Issue 5759: __float__ not called on str subclasses (though it is on
|
|
# unicode subclasses).
|
|
class FooStr(str):
|
|
def __float__(self):
|
|
return float(str(self)) + 1
|
|
|
|
class FooUnicode(unicode):
|
|
def __float__(self):
|
|
return float(unicode(self)) + 1
|
|
|
|
self.assertAlmostEqual(float(Foo0()), 42.)
|
|
self.assertAlmostEqual(float(Foo1()), 42.)
|
|
self.assertAlmostEqual(float(Foo2()), 42.)
|
|
self.assertAlmostEqual(float(Foo3(21)), 42.)
|
|
self.assertRaises(TypeError, float, Foo4(42))
|
|
self.assertAlmostEqual(float(FooUnicode('8')), 9.)
|
|
self.assertAlmostEqual(float(FooStr('8')), 9.)
|
|
|
|
def test_floatasratio(self):
|
|
for f, ratio in [
|
|
(0.875, (7, 8)),
|
|
(-0.875, (-7, 8)),
|
|
(0.0, (0, 1)),
|
|
(11.5, (23, 2)),
|
|
]:
|
|
self.assertEqual(f.as_integer_ratio(), ratio)
|
|
|
|
for i in range(10000):
|
|
f = random.random()
|
|
f *= 10 ** random.randint(-100, 100)
|
|
n, d = f.as_integer_ratio()
|
|
self.assertEqual(float(n).__truediv__(d), f)
|
|
|
|
R = fractions.Fraction
|
|
self.assertEqual(R(0, 1),
|
|
R(*float(0.0).as_integer_ratio()))
|
|
self.assertEqual(R(5, 2),
|
|
R(*float(2.5).as_integer_ratio()))
|
|
self.assertEqual(R(1, 2),
|
|
R(*float(0.5).as_integer_ratio()))
|
|
self.assertEqual(R(4728779608739021, 2251799813685248),
|
|
R(*float(2.1).as_integer_ratio()))
|
|
self.assertEqual(R(-4728779608739021, 2251799813685248),
|
|
R(*float(-2.1).as_integer_ratio()))
|
|
self.assertEqual(R(-2100, 1),
|
|
R(*float(-2100.0).as_integer_ratio()))
|
|
|
|
self.assertRaises(OverflowError, float('inf').as_integer_ratio)
|
|
self.assertRaises(OverflowError, float('-inf').as_integer_ratio)
|
|
self.assertRaises(ValueError, float('nan').as_integer_ratio)
|
|
|
|
def assertEqualAndEqualSign(self, a, b):
|
|
# fail unless a == b and a and b have the same sign bit;
|
|
# the only difference from assertEqual is that this test
|
|
# distingishes -0.0 and 0.0.
|
|
self.assertEqual((a, copysign(1.0, a)), (b, copysign(1.0, b)))
|
|
|
|
@requires_IEEE_754
|
|
def test_float_pow(self):
|
|
# test builtin pow and ** operator for IEEE 754 special cases.
|
|
# Special cases taken from section F.9.4.4 of the C99 specification
|
|
|
|
for pow_op in pow, operator.pow:
|
|
# x**NAN is NAN for any x except 1
|
|
self.assertTrue(isnan(pow_op(-INF, NAN)))
|
|
self.assertTrue(isnan(pow_op(-2.0, NAN)))
|
|
self.assertTrue(isnan(pow_op(-1.0, NAN)))
|
|
self.assertTrue(isnan(pow_op(-0.5, NAN)))
|
|
self.assertTrue(isnan(pow_op(-0.0, NAN)))
|
|
self.assertTrue(isnan(pow_op(0.0, NAN)))
|
|
self.assertTrue(isnan(pow_op(0.5, NAN)))
|
|
self.assertTrue(isnan(pow_op(2.0, NAN)))
|
|
self.assertTrue(isnan(pow_op(INF, NAN)))
|
|
self.assertTrue(isnan(pow_op(NAN, NAN)))
|
|
|
|
# NAN**y is NAN for any y except +-0
|
|
self.assertTrue(isnan(pow_op(NAN, -INF)))
|
|
self.assertTrue(isnan(pow_op(NAN, -2.0)))
|
|
self.assertTrue(isnan(pow_op(NAN, -1.0)))
|
|
self.assertTrue(isnan(pow_op(NAN, -0.5)))
|
|
self.assertTrue(isnan(pow_op(NAN, 0.5)))
|
|
self.assertTrue(isnan(pow_op(NAN, 1.0)))
|
|
self.assertTrue(isnan(pow_op(NAN, 2.0)))
|
|
self.assertTrue(isnan(pow_op(NAN, INF)))
|
|
|
|
# (+-0)**y raises ZeroDivisionError for y a negative odd integer
|
|
self.assertRaises(ZeroDivisionError, pow_op, -0.0, -1.0)
|
|
self.assertRaises(ZeroDivisionError, pow_op, 0.0, -1.0)
|
|
|
|
# (+-0)**y raises ZeroDivisionError for y finite and negative
|
|
# but not an odd integer
|
|
self.assertRaises(ZeroDivisionError, pow_op, -0.0, -2.0)
|
|
self.assertRaises(ZeroDivisionError, pow_op, -0.0, -0.5)
|
|
self.assertRaises(ZeroDivisionError, pow_op, 0.0, -2.0)
|
|
self.assertRaises(ZeroDivisionError, pow_op, 0.0, -0.5)
|
|
|
|
# (+-0)**y is +-0 for y a positive odd integer
|
|
self.assertEqualAndEqualSign(pow_op(-0.0, 1.0), -0.0)
|
|
self.assertEqualAndEqualSign(pow_op(0.0, 1.0), 0.0)
|
|
|
|
# (+-0)**y is 0 for y finite and positive but not an odd integer
|
|
self.assertEqualAndEqualSign(pow_op(-0.0, 0.5), 0.0)
|
|
self.assertEqualAndEqualSign(pow_op(-0.0, 2.0), 0.0)
|
|
self.assertEqualAndEqualSign(pow_op(0.0, 0.5), 0.0)
|
|
self.assertEqualAndEqualSign(pow_op(0.0, 2.0), 0.0)
|
|
|
|
# (-1)**+-inf is 1
|
|
self.assertEqualAndEqualSign(pow_op(-1.0, -INF), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(-1.0, INF), 1.0)
|
|
|
|
# 1**y is 1 for any y, even if y is an infinity or nan
|
|
self.assertEqualAndEqualSign(pow_op(1.0, -INF), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(1.0, -2.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(1.0, -1.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(1.0, -0.5), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(1.0, -0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(1.0, 0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(1.0, 0.5), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(1.0, 1.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(1.0, 2.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(1.0, INF), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(1.0, NAN), 1.0)
|
|
|
|
# x**+-0 is 1 for any x, even if x is a zero, infinity, or nan
|
|
self.assertEqualAndEqualSign(pow_op(-INF, 0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(-2.0, 0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(-1.0, 0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(-0.5, 0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(-0.0, 0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(0.0, 0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(0.5, 0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(1.0, 0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(2.0, 0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(INF, 0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(NAN, 0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(-INF, -0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(-2.0, -0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(-1.0, -0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(-0.5, -0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(-0.0, -0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(0.0, -0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(0.5, -0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(1.0, -0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(2.0, -0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(INF, -0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(NAN, -0.0), 1.0)
|
|
|
|
# x**y raises ValueError for finite negative x and non-integral y
|
|
self.assertRaises(ValueError, pow_op, -2.0, -0.5)
|
|
self.assertRaises(ValueError, pow_op, -2.0, 0.5)
|
|
self.assertRaises(ValueError, pow_op, -1.0, -0.5)
|
|
self.assertRaises(ValueError, pow_op, -1.0, 0.5)
|
|
self.assertRaises(ValueError, pow_op, -0.5, -0.5)
|
|
self.assertRaises(ValueError, pow_op, -0.5, 0.5)
|
|
|
|
# x**-INF is INF for abs(x) < 1
|
|
self.assertEqualAndEqualSign(pow_op(-0.5, -INF), INF)
|
|
self.assertEqualAndEqualSign(pow_op(-0.0, -INF), INF)
|
|
self.assertEqualAndEqualSign(pow_op(0.0, -INF), INF)
|
|
self.assertEqualAndEqualSign(pow_op(0.5, -INF), INF)
|
|
|
|
# x**-INF is 0 for abs(x) > 1
|
|
self.assertEqualAndEqualSign(pow_op(-INF, -INF), 0.0)
|
|
self.assertEqualAndEqualSign(pow_op(-2.0, -INF), 0.0)
|
|
self.assertEqualAndEqualSign(pow_op(2.0, -INF), 0.0)
|
|
self.assertEqualAndEqualSign(pow_op(INF, -INF), 0.0)
|
|
|
|
# x**INF is 0 for abs(x) < 1
|
|
self.assertEqualAndEqualSign(pow_op(-0.5, INF), 0.0)
|
|
self.assertEqualAndEqualSign(pow_op(-0.0, INF), 0.0)
|
|
self.assertEqualAndEqualSign(pow_op(0.0, INF), 0.0)
|
|
self.assertEqualAndEqualSign(pow_op(0.5, INF), 0.0)
|
|
|
|
# x**INF is INF for abs(x) > 1
|
|
self.assertEqualAndEqualSign(pow_op(-INF, INF), INF)
|
|
self.assertEqualAndEqualSign(pow_op(-2.0, INF), INF)
|
|
self.assertEqualAndEqualSign(pow_op(2.0, INF), INF)
|
|
self.assertEqualAndEqualSign(pow_op(INF, INF), INF)
|
|
|
|
# (-INF)**y is -0.0 for y a negative odd integer
|
|
self.assertEqualAndEqualSign(pow_op(-INF, -1.0), -0.0)
|
|
|
|
# (-INF)**y is 0.0 for y negative but not an odd integer
|
|
self.assertEqualAndEqualSign(pow_op(-INF, -0.5), 0.0)
|
|
self.assertEqualAndEqualSign(pow_op(-INF, -2.0), 0.0)
|
|
|
|
# (-INF)**y is -INF for y a positive odd integer
|
|
self.assertEqualAndEqualSign(pow_op(-INF, 1.0), -INF)
|
|
|
|
# (-INF)**y is INF for y positive but not an odd integer
|
|
self.assertEqualAndEqualSign(pow_op(-INF, 0.5), INF)
|
|
self.assertEqualAndEqualSign(pow_op(-INF, 2.0), INF)
|
|
|
|
# INF**y is INF for y positive
|
|
self.assertEqualAndEqualSign(pow_op(INF, 0.5), INF)
|
|
self.assertEqualAndEqualSign(pow_op(INF, 1.0), INF)
|
|
self.assertEqualAndEqualSign(pow_op(INF, 2.0), INF)
|
|
|
|
# INF**y is 0.0 for y negative
|
|
self.assertEqualAndEqualSign(pow_op(INF, -2.0), 0.0)
|
|
self.assertEqualAndEqualSign(pow_op(INF, -1.0), 0.0)
|
|
self.assertEqualAndEqualSign(pow_op(INF, -0.5), 0.0)
|
|
|
|
# basic checks not covered by the special cases above
|
|
self.assertEqualAndEqualSign(pow_op(-2.0, -2.0), 0.25)
|
|
self.assertEqualAndEqualSign(pow_op(-2.0, -1.0), -0.5)
|
|
self.assertEqualAndEqualSign(pow_op(-2.0, -0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(-2.0, 0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(-2.0, 1.0), -2.0)
|
|
self.assertEqualAndEqualSign(pow_op(-2.0, 2.0), 4.0)
|
|
self.assertEqualAndEqualSign(pow_op(-1.0, -2.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(-1.0, -1.0), -1.0)
|
|
self.assertEqualAndEqualSign(pow_op(-1.0, -0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(-1.0, 0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(-1.0, 1.0), -1.0)
|
|
self.assertEqualAndEqualSign(pow_op(-1.0, 2.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(2.0, -2.0), 0.25)
|
|
self.assertEqualAndEqualSign(pow_op(2.0, -1.0), 0.5)
|
|
self.assertEqualAndEqualSign(pow_op(2.0, -0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(2.0, 0.0), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(2.0, 1.0), 2.0)
|
|
self.assertEqualAndEqualSign(pow_op(2.0, 2.0), 4.0)
|
|
|
|
# 1 ** large and -1 ** large; some libms apparently
|
|
# have problems with these
|
|
self.assertEqualAndEqualSign(pow_op(1.0, -1e100), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(1.0, 1e100), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(-1.0, -1e100), 1.0)
|
|
self.assertEqualAndEqualSign(pow_op(-1.0, 1e100), 1.0)
|
|
|
|
# check sign for results that underflow to 0
|
|
self.assertEqualAndEqualSign(pow_op(-2.0, -2000.0), 0.0)
|
|
self.assertRaises(ValueError, pow_op, -2.0, -2000.5)
|
|
self.assertEqualAndEqualSign(pow_op(-2.0, -2001.0), -0.0)
|
|
self.assertEqualAndEqualSign(pow_op(2.0, -2000.0), 0.0)
|
|
self.assertEqualAndEqualSign(pow_op(2.0, -2000.5), 0.0)
|
|
self.assertEqualAndEqualSign(pow_op(2.0, -2001.0), 0.0)
|
|
self.assertEqualAndEqualSign(pow_op(-0.5, 2000.0), 0.0)
|
|
self.assertRaises(ValueError, pow_op, -0.5, 2000.5)
|
|
self.assertEqualAndEqualSign(pow_op(-0.5, 2001.0), -0.0)
|
|
self.assertEqualAndEqualSign(pow_op(0.5, 2000.0), 0.0)
|
|
self.assertEqualAndEqualSign(pow_op(0.5, 2000.5), 0.0)
|
|
self.assertEqualAndEqualSign(pow_op(0.5, 2001.0), 0.0)
|
|
|
|
# check we don't raise an exception for subnormal results,
|
|
# and validate signs. Tests currently disabled, since
|
|
# they fail on systems where a subnormal result from pow
|
|
# is flushed to zero (e.g. Debian/ia64.)
|
|
#self.assertTrue(0.0 < pow_op(0.5, 1048) < 1e-315)
|
|
#self.assertTrue(0.0 < pow_op(-0.5, 1048) < 1e-315)
|
|
#self.assertTrue(0.0 < pow_op(0.5, 1047) < 1e-315)
|
|
#self.assertTrue(0.0 > pow_op(-0.5, 1047) > -1e-315)
|
|
#self.assertTrue(0.0 < pow_op(2.0, -1048) < 1e-315)
|
|
#self.assertTrue(0.0 < pow_op(-2.0, -1048) < 1e-315)
|
|
#self.assertTrue(0.0 < pow_op(2.0, -1047) < 1e-315)
|
|
#self.assertTrue(0.0 > pow_op(-2.0, -1047) > -1e-315)
|
|
|
|
|
|
class FormatFunctionsTestCase(unittest.TestCase):
|
|
|
|
def setUp(self):
|
|
self.save_formats = {'double':float.__getformat__('double'),
|
|
'float':float.__getformat__('float')}
|
|
|
|
def tearDown(self):
|
|
float.__setformat__('double', self.save_formats['double'])
|
|
float.__setformat__('float', self.save_formats['float'])
|
|
|
|
def test_getformat(self):
|
|
self.assertIn(float.__getformat__('double'),
|
|
['unknown', 'IEEE, big-endian', 'IEEE, little-endian'])
|
|
self.assertIn(float.__getformat__('float'),
|
|
['unknown', 'IEEE, big-endian', 'IEEE, little-endian'])
|
|
self.assertRaises(ValueError, float.__getformat__, 'chicken')
|
|
self.assertRaises(TypeError, float.__getformat__, 1)
|
|
|
|
def test_setformat(self):
|
|
for t in 'double', 'float':
|
|
float.__setformat__(t, 'unknown')
|
|
if self.save_formats[t] == 'IEEE, big-endian':
|
|
self.assertRaises(ValueError, float.__setformat__,
|
|
t, 'IEEE, little-endian')
|
|
elif self.save_formats[t] == 'IEEE, little-endian':
|
|
self.assertRaises(ValueError, float.__setformat__,
|
|
t, 'IEEE, big-endian')
|
|
else:
|
|
self.assertRaises(ValueError, float.__setformat__,
|
|
t, 'IEEE, big-endian')
|
|
self.assertRaises(ValueError, float.__setformat__,
|
|
t, 'IEEE, little-endian')
|
|
self.assertRaises(ValueError, float.__setformat__,
|
|
t, 'chicken')
|
|
self.assertRaises(ValueError, float.__setformat__,
|
|
'chicken', 'unknown')
|
|
|
|
BE_DOUBLE_INF = '\x7f\xf0\x00\x00\x00\x00\x00\x00'
|
|
LE_DOUBLE_INF = ''.join(reversed(BE_DOUBLE_INF))
|
|
BE_DOUBLE_NAN = '\x7f\xf8\x00\x00\x00\x00\x00\x00'
|
|
LE_DOUBLE_NAN = ''.join(reversed(BE_DOUBLE_NAN))
|
|
|
|
BE_FLOAT_INF = '\x7f\x80\x00\x00'
|
|
LE_FLOAT_INF = ''.join(reversed(BE_FLOAT_INF))
|
|
BE_FLOAT_NAN = '\x7f\xc0\x00\x00'
|
|
LE_FLOAT_NAN = ''.join(reversed(BE_FLOAT_NAN))
|
|
|
|
# on non-IEEE platforms, attempting to unpack a bit pattern
|
|
# representing an infinity or a NaN should raise an exception.
|
|
|
|
class UnknownFormatTestCase(unittest.TestCase):
|
|
def setUp(self):
|
|
self.save_formats = {'double':float.__getformat__('double'),
|
|
'float':float.__getformat__('float')}
|
|
float.__setformat__('double', 'unknown')
|
|
float.__setformat__('float', 'unknown')
|
|
|
|
def tearDown(self):
|
|
float.__setformat__('double', self.save_formats['double'])
|
|
float.__setformat__('float', self.save_formats['float'])
|
|
|
|
def test_double_specials_dont_unpack(self):
|
|
for fmt, data in [('>d', BE_DOUBLE_INF),
|
|
('>d', BE_DOUBLE_NAN),
|
|
('<d', LE_DOUBLE_INF),
|
|
('<d', LE_DOUBLE_NAN)]:
|
|
self.assertRaises(ValueError, struct.unpack, fmt, data)
|
|
|
|
def test_float_specials_dont_unpack(self):
|
|
for fmt, data in [('>f', BE_FLOAT_INF),
|
|
('>f', BE_FLOAT_NAN),
|
|
('<f', LE_FLOAT_INF),
|
|
('<f', LE_FLOAT_NAN)]:
|
|
self.assertRaises(ValueError, struct.unpack, fmt, data)
|
|
|
|
|
|
# on an IEEE platform, all we guarantee is that bit patterns
|
|
# representing infinities or NaNs do not raise an exception; all else
|
|
# is accident (today).
|
|
# let's also try to guarantee that -0.0 and 0.0 don't get confused.
|
|
|
|
class IEEEFormatTestCase(unittest.TestCase):
|
|
if float.__getformat__("double").startswith("IEEE"):
|
|
def test_double_specials_do_unpack(self):
|
|
for fmt, data in [('>d', BE_DOUBLE_INF),
|
|
('>d', BE_DOUBLE_NAN),
|
|
('<d', LE_DOUBLE_INF),
|
|
('<d', LE_DOUBLE_NAN)]:
|
|
struct.unpack(fmt, data)
|
|
|
|
if float.__getformat__("float").startswith("IEEE"):
|
|
def test_float_specials_do_unpack(self):
|
|
for fmt, data in [('>f', BE_FLOAT_INF),
|
|
('>f', BE_FLOAT_NAN),
|
|
('<f', LE_FLOAT_INF),
|
|
('<f', LE_FLOAT_NAN)]:
|
|
struct.unpack(fmt, data)
|
|
|
|
if float.__getformat__("double").startswith("IEEE"):
|
|
def test_negative_zero(self):
|
|
def pos_pos():
|
|
return 0.0, math.atan2(0.0, -1)
|
|
def pos_neg():
|
|
return 0.0, math.atan2(-0.0, -1)
|
|
def neg_pos():
|
|
return -0.0, math.atan2(0.0, -1)
|
|
def neg_neg():
|
|
return -0.0, math.atan2(-0.0, -1)
|
|
self.assertEquals(pos_pos(), neg_pos())
|
|
self.assertEquals(pos_neg(), neg_neg())
|
|
|
|
if float.__getformat__("double").startswith("IEEE"):
|
|
def test_underflow_sign(self):
|
|
# check that -1e-1000 gives -0.0, not 0.0
|
|
self.assertEquals(math.atan2(-1e-1000, -1), math.atan2(-0.0, -1))
|
|
self.assertEquals(math.atan2(float('-1e-1000'), -1),
|
|
math.atan2(-0.0, -1))
|
|
|
|
def test_format(self):
|
|
# these should be rewritten to use both format(x, spec) and
|
|
# x.__format__(spec)
|
|
|
|
self.assertEqual(format(0.0, 'f'), '0.000000')
|
|
|
|
# the default is 'g', except for empty format spec
|
|
self.assertEqual(format(0.0, ''), '0.0')
|
|
self.assertEqual(format(0.01, ''), '0.01')
|
|
self.assertEqual(format(0.01, 'g'), '0.01')
|
|
|
|
# empty presentation type should format in the same way as str
|
|
# (issue 5920)
|
|
x = 100/7.
|
|
self.assertEqual(format(x, ''), str(x))
|
|
self.assertEqual(format(x, '-'), str(x))
|
|
self.assertEqual(format(x, '>'), str(x))
|
|
self.assertEqual(format(x, '2'), str(x))
|
|
|
|
self.assertEqual(format(1.0, 'f'), '1.000000')
|
|
|
|
self.assertEqual(format(-1.0, 'f'), '-1.000000')
|
|
|
|
self.assertEqual(format( 1.0, ' f'), ' 1.000000')
|
|
self.assertEqual(format(-1.0, ' f'), '-1.000000')
|
|
self.assertEqual(format( 1.0, '+f'), '+1.000000')
|
|
self.assertEqual(format(-1.0, '+f'), '-1.000000')
|
|
|
|
# % formatting
|
|
self.assertEqual(format(-1.0, '%'), '-100.000000%')
|
|
|
|
# conversion to string should fail
|
|
self.assertRaises(ValueError, format, 3.0, "s")
|
|
|
|
# other format specifiers shouldn't work on floats,
|
|
# in particular int specifiers
|
|
for format_spec in ([chr(x) for x in range(ord('a'), ord('z')+1)] +
|
|
[chr(x) for x in range(ord('A'), ord('Z')+1)]):
|
|
if not format_spec in 'eEfFgGn%':
|
|
self.assertRaises(ValueError, format, 0.0, format_spec)
|
|
self.assertRaises(ValueError, format, 1.0, format_spec)
|
|
self.assertRaises(ValueError, format, -1.0, format_spec)
|
|
self.assertRaises(ValueError, format, 1e100, format_spec)
|
|
self.assertRaises(ValueError, format, -1e100, format_spec)
|
|
self.assertRaises(ValueError, format, 1e-100, format_spec)
|
|
self.assertRaises(ValueError, format, -1e-100, format_spec)
|
|
|
|
# issue 3382: 'f' and 'F' with inf's and nan's
|
|
self.assertEqual('{0:f}'.format(INF), 'inf')
|
|
self.assertEqual('{0:F}'.format(INF), 'INF')
|
|
self.assertEqual('{0:f}'.format(-INF), '-inf')
|
|
self.assertEqual('{0:F}'.format(-INF), '-INF')
|
|
self.assertEqual('{0:f}'.format(NAN), 'nan')
|
|
self.assertEqual('{0:F}'.format(NAN), 'NAN')
|
|
|
|
@unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
|
|
"test requires IEEE 754 doubles")
|
|
def test_format_testfile(self):
|
|
for line in open(format_testfile):
|
|
if line.startswith('--'):
|
|
continue
|
|
line = line.strip()
|
|
if not line:
|
|
continue
|
|
|
|
lhs, rhs = map(str.strip, line.split('->'))
|
|
fmt, arg = lhs.split()
|
|
arg = float(arg)
|
|
self.assertEqual(fmt % arg, rhs)
|
|
if not math.isnan(arg) and copysign(1.0, arg) > 0.0:
|
|
self.assertEqual(fmt % -arg, '-' + rhs)
|
|
|
|
def test_issue5864(self):
|
|
self.assertEquals(format(123.456, '.4'), '123.5')
|
|
self.assertEquals(format(1234.56, '.4'), '1.235e+03')
|
|
self.assertEquals(format(12345.6, '.4'), '1.235e+04')
|
|
|
|
class ReprTestCase(unittest.TestCase):
|
|
def test_repr(self):
|
|
floats_file = open(os.path.join(os.path.split(__file__)[0],
|
|
'floating_points.txt'))
|
|
for line in floats_file:
|
|
line = line.strip()
|
|
if not line or line.startswith('#'):
|
|
continue
|
|
v = eval(line)
|
|
self.assertEqual(v, eval(repr(v)))
|
|
floats_file.close()
|
|
|
|
@unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short',
|
|
"applies only when using short float repr style")
|
|
def test_short_repr(self):
|
|
# test short float repr introduced in Python 3.1. One aspect
|
|
# of this repr is that we get some degree of str -> float ->
|
|
# str roundtripping. In particular, for any numeric string
|
|
# containing 15 or fewer significant digits, those exact same
|
|
# digits (modulo trailing zeros) should appear in the output.
|
|
# No more repr(0.03) -> "0.029999999999999999"!
|
|
|
|
test_strings = [
|
|
# output always includes *either* a decimal point and at
|
|
# least one digit after that point, or an exponent.
|
|
'0.0',
|
|
'1.0',
|
|
'0.01',
|
|
'0.02',
|
|
'0.03',
|
|
'0.04',
|
|
'0.05',
|
|
'1.23456789',
|
|
'10.0',
|
|
'100.0',
|
|
# values >= 1e16 get an exponent...
|
|
'1000000000000000.0',
|
|
'9999999999999990.0',
|
|
'1e+16',
|
|
'1e+17',
|
|
# ... and so do values < 1e-4
|
|
'0.001',
|
|
'0.001001',
|
|
'0.00010000000000001',
|
|
'0.0001',
|
|
'9.999999999999e-05',
|
|
'1e-05',
|
|
# values designed to provoke failure if the FPU rounding
|
|
# precision isn't set correctly
|
|
'8.72293771110361e+25',
|
|
'7.47005307342313e+26',
|
|
'2.86438000439698e+28',
|
|
'8.89142905246179e+28',
|
|
'3.08578087079232e+35',
|
|
]
|
|
|
|
for s in test_strings:
|
|
negs = '-'+s
|
|
self.assertEqual(s, repr(float(s)))
|
|
self.assertEqual(negs, repr(float(negs)))
|
|
|
|
@unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
|
|
"test requires IEEE 754 doubles")
|
|
class RoundTestCase(unittest.TestCase):
|
|
def test_second_argument_type(self):
|
|
# any type with an __index__ method should be permitted as
|
|
# a second argument
|
|
self.assertAlmostEqual(round(12.34, True), 12.3)
|
|
|
|
class MyIndex(object):
|
|
def __index__(self): return 4
|
|
self.assertAlmostEqual(round(-0.123456, MyIndex()), -0.1235)
|
|
# but floats should be illegal
|
|
self.assertRaises(TypeError, round, 3.14159, 2.0)
|
|
|
|
def test_inf_nan(self):
|
|
# rounding an infinity or nan returns the same number;
|
|
# (in py3k, rounding an infinity or nan raises an error,
|
|
# since the result can't be represented as a long).
|
|
self.assertEqual(round(INF), INF)
|
|
self.assertEqual(round(-INF), -INF)
|
|
self.assertTrue(math.isnan(round(NAN)))
|
|
for n in range(-5, 5):
|
|
self.assertEqual(round(INF, n), INF)
|
|
self.assertEqual(round(-INF, n), -INF)
|
|
self.assertTrue(math.isnan(round(NAN, n)))
|
|
|
|
self.assertRaises(TypeError, round, INF, 0.0)
|
|
self.assertRaises(TypeError, round, -INF, 1.0)
|
|
self.assertRaises(TypeError, round, NAN, "ceci n'est pas un integer")
|
|
self.assertRaises(TypeError, round, -0.0, 1j)
|
|
|
|
def test_large_n(self):
|
|
for n in [324, 325, 400, 2**31-1, 2**31, 2**32, 2**100]:
|
|
self.assertEqual(round(123.456, n), 123.456)
|
|
self.assertEqual(round(-123.456, n), -123.456)
|
|
self.assertEqual(round(1e300, n), 1e300)
|
|
self.assertEqual(round(1e-320, n), 1e-320)
|
|
self.assertEqual(round(1e150, 300), 1e150)
|
|
self.assertEqual(round(1e300, 307), 1e300)
|
|
self.assertEqual(round(-3.1415, 308), -3.1415)
|
|
self.assertEqual(round(1e150, 309), 1e150)
|
|
self.assertEqual(round(1.4e-315, 315), 1e-315)
|
|
|
|
def test_small_n(self):
|
|
for n in [-308, -309, -400, 1-2**31, -2**31, -2**31-1, -2**100]:
|
|
self.assertEqual(round(123.456, n), 0.0)
|
|
self.assertEqual(round(-123.456, n), -0.0)
|
|
self.assertEqual(round(1e300, n), 0.0)
|
|
self.assertEqual(round(1e-320, n), 0.0)
|
|
|
|
def test_overflow(self):
|
|
self.assertRaises(OverflowError, round, 1.6e308, -308)
|
|
self.assertRaises(OverflowError, round, -1.7e308, -308)
|
|
|
|
@unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short',
|
|
"test applies only when using short float repr style")
|
|
def test_previous_round_bugs(self):
|
|
# particular cases that have occurred in bug reports
|
|
self.assertEqual(round(562949953421312.5, 1),
|
|
562949953421312.5)
|
|
self.assertEqual(round(56294995342131.5, 3),
|
|
56294995342131.5)
|
|
|
|
@unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short',
|
|
"test applies only when using short float repr style")
|
|
def test_halfway_cases(self):
|
|
# Halfway cases need special attention, since the current
|
|
# implementation has to deal with them specially. Note that
|
|
# 2.x rounds halfway values up (i.e., away from zero) while
|
|
# 3.x does round-half-to-even.
|
|
self.assertAlmostEqual(round(0.125, 2), 0.13)
|
|
self.assertAlmostEqual(round(0.375, 2), 0.38)
|
|
self.assertAlmostEqual(round(0.625, 2), 0.63)
|
|
self.assertAlmostEqual(round(0.875, 2), 0.88)
|
|
self.assertAlmostEqual(round(-0.125, 2), -0.13)
|
|
self.assertAlmostEqual(round(-0.375, 2), -0.38)
|
|
self.assertAlmostEqual(round(-0.625, 2), -0.63)
|
|
self.assertAlmostEqual(round(-0.875, 2), -0.88)
|
|
|
|
self.assertAlmostEqual(round(0.25, 1), 0.3)
|
|
self.assertAlmostEqual(round(0.75, 1), 0.8)
|
|
self.assertAlmostEqual(round(-0.25, 1), -0.3)
|
|
self.assertAlmostEqual(round(-0.75, 1), -0.8)
|
|
|
|
self.assertEqual(round(-6.5, 0), -7.0)
|
|
self.assertEqual(round(-5.5, 0), -6.0)
|
|
self.assertEqual(round(-1.5, 0), -2.0)
|
|
self.assertEqual(round(-0.5, 0), -1.0)
|
|
self.assertEqual(round(0.5, 0), 1.0)
|
|
self.assertEqual(round(1.5, 0), 2.0)
|
|
self.assertEqual(round(2.5, 0), 3.0)
|
|
self.assertEqual(round(3.5, 0), 4.0)
|
|
self.assertEqual(round(4.5, 0), 5.0)
|
|
self.assertEqual(round(5.5, 0), 6.0)
|
|
self.assertEqual(round(6.5, 0), 7.0)
|
|
|
|
# same but without an explicit second argument; in 3.x these
|
|
# will give integers
|
|
self.assertEqual(round(-6.5), -7.0)
|
|
self.assertEqual(round(-5.5), -6.0)
|
|
self.assertEqual(round(-1.5), -2.0)
|
|
self.assertEqual(round(-0.5), -1.0)
|
|
self.assertEqual(round(0.5), 1.0)
|
|
self.assertEqual(round(1.5), 2.0)
|
|
self.assertEqual(round(2.5), 3.0)
|
|
self.assertEqual(round(3.5), 4.0)
|
|
self.assertEqual(round(4.5), 5.0)
|
|
self.assertEqual(round(5.5), 6.0)
|
|
self.assertEqual(round(6.5), 7.0)
|
|
|
|
self.assertEqual(round(-25.0, -1), -30.0)
|
|
self.assertEqual(round(-15.0, -1), -20.0)
|
|
self.assertEqual(round(-5.0, -1), -10.0)
|
|
self.assertEqual(round(5.0, -1), 10.0)
|
|
self.assertEqual(round(15.0, -1), 20.0)
|
|
self.assertEqual(round(25.0, -1), 30.0)
|
|
self.assertEqual(round(35.0, -1), 40.0)
|
|
self.assertEqual(round(45.0, -1), 50.0)
|
|
self.assertEqual(round(55.0, -1), 60.0)
|
|
self.assertEqual(round(65.0, -1), 70.0)
|
|
self.assertEqual(round(75.0, -1), 80.0)
|
|
self.assertEqual(round(85.0, -1), 90.0)
|
|
self.assertEqual(round(95.0, -1), 100.0)
|
|
self.assertEqual(round(12325.0, -1), 12330.0)
|
|
|
|
self.assertEqual(round(350.0, -2), 400.0)
|
|
self.assertEqual(round(450.0, -2), 500.0)
|
|
|
|
self.assertAlmostEqual(round(0.5e21, -21), 1e21)
|
|
self.assertAlmostEqual(round(1.5e21, -21), 2e21)
|
|
self.assertAlmostEqual(round(2.5e21, -21), 3e21)
|
|
self.assertAlmostEqual(round(5.5e21, -21), 6e21)
|
|
self.assertAlmostEqual(round(8.5e21, -21), 9e21)
|
|
|
|
self.assertAlmostEqual(round(-1.5e22, -22), -2e22)
|
|
self.assertAlmostEqual(round(-0.5e22, -22), -1e22)
|
|
self.assertAlmostEqual(round(0.5e22, -22), 1e22)
|
|
self.assertAlmostEqual(round(1.5e22, -22), 2e22)
|
|
|
|
@unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
|
|
"test requires IEEE 754 doubles")
|
|
def test_format_specials(self):
|
|
# Test formatting of nans and infs.
|
|
|
|
def test(fmt, value, expected):
|
|
# Test with both % and format().
|
|
self.assertEqual(fmt % value, expected, fmt)
|
|
if not '#' in fmt:
|
|
# Until issue 7094 is implemented, format() for floats doesn't
|
|
# support '#' formatting
|
|
fmt = fmt[1:] # strip off the %
|
|
self.assertEqual(format(value, fmt), expected, fmt)
|
|
|
|
for fmt in ['%e', '%f', '%g', '%.0e', '%.6f', '%.20g',
|
|
'%#e', '%#f', '%#g', '%#.20e', '%#.15f', '%#.3g']:
|
|
pfmt = '%+' + fmt[1:]
|
|
sfmt = '% ' + fmt[1:]
|
|
test(fmt, INF, 'inf')
|
|
test(fmt, -INF, '-inf')
|
|
test(fmt, NAN, 'nan')
|
|
test(fmt, -NAN, 'nan')
|
|
# When asking for a sign, it's always provided. nans are
|
|
# always positive.
|
|
test(pfmt, INF, '+inf')
|
|
test(pfmt, -INF, '-inf')
|
|
test(pfmt, NAN, '+nan')
|
|
test(pfmt, -NAN, '+nan')
|
|
# When using ' ' for a sign code, only infs can be negative.
|
|
# Others have a space.
|
|
test(sfmt, INF, ' inf')
|
|
test(sfmt, -INF, '-inf')
|
|
test(sfmt, NAN, ' nan')
|
|
test(sfmt, -NAN, ' nan')
|
|
|
|
|
|
# Beginning with Python 2.6 float has cross platform compatible
|
|
# ways to create and represent inf and nan
|
|
class InfNanTest(unittest.TestCase):
|
|
def test_inf_from_str(self):
|
|
self.assertTrue(isinf(float("inf")))
|
|
self.assertTrue(isinf(float("+inf")))
|
|
self.assertTrue(isinf(float("-inf")))
|
|
self.assertTrue(isinf(float("infinity")))
|
|
self.assertTrue(isinf(float("+infinity")))
|
|
self.assertTrue(isinf(float("-infinity")))
|
|
|
|
self.assertEqual(repr(float("inf")), "inf")
|
|
self.assertEqual(repr(float("+inf")), "inf")
|
|
self.assertEqual(repr(float("-inf")), "-inf")
|
|
self.assertEqual(repr(float("infinity")), "inf")
|
|
self.assertEqual(repr(float("+infinity")), "inf")
|
|
self.assertEqual(repr(float("-infinity")), "-inf")
|
|
|
|
self.assertEqual(repr(float("INF")), "inf")
|
|
self.assertEqual(repr(float("+Inf")), "inf")
|
|
self.assertEqual(repr(float("-iNF")), "-inf")
|
|
self.assertEqual(repr(float("Infinity")), "inf")
|
|
self.assertEqual(repr(float("+iNfInItY")), "inf")
|
|
self.assertEqual(repr(float("-INFINITY")), "-inf")
|
|
|
|
self.assertEqual(str(float("inf")), "inf")
|
|
self.assertEqual(str(float("+inf")), "inf")
|
|
self.assertEqual(str(float("-inf")), "-inf")
|
|
self.assertEqual(str(float("infinity")), "inf")
|
|
self.assertEqual(str(float("+infinity")), "inf")
|
|
self.assertEqual(str(float("-infinity")), "-inf")
|
|
|
|
self.assertRaises(ValueError, float, "info")
|
|
self.assertRaises(ValueError, float, "+info")
|
|
self.assertRaises(ValueError, float, "-info")
|
|
self.assertRaises(ValueError, float, "in")
|
|
self.assertRaises(ValueError, float, "+in")
|
|
self.assertRaises(ValueError, float, "-in")
|
|
self.assertRaises(ValueError, float, "infinit")
|
|
self.assertRaises(ValueError, float, "+Infin")
|
|
self.assertRaises(ValueError, float, "-INFI")
|
|
self.assertRaises(ValueError, float, "infinitys")
|
|
|
|
def test_inf_as_str(self):
|
|
self.assertEqual(repr(1e300 * 1e300), "inf")
|
|
self.assertEqual(repr(-1e300 * 1e300), "-inf")
|
|
|
|
self.assertEqual(str(1e300 * 1e300), "inf")
|
|
self.assertEqual(str(-1e300 * 1e300), "-inf")
|
|
|
|
def test_nan_from_str(self):
|
|
self.assertTrue(isnan(float("nan")))
|
|
self.assertTrue(isnan(float("+nan")))
|
|
self.assertTrue(isnan(float("-nan")))
|
|
|
|
self.assertEqual(repr(float("nan")), "nan")
|
|
self.assertEqual(repr(float("+nan")), "nan")
|
|
self.assertEqual(repr(float("-nan")), "nan")
|
|
|
|
self.assertEqual(repr(float("NAN")), "nan")
|
|
self.assertEqual(repr(float("+NAn")), "nan")
|
|
self.assertEqual(repr(float("-NaN")), "nan")
|
|
|
|
self.assertEqual(str(float("nan")), "nan")
|
|
self.assertEqual(str(float("+nan")), "nan")
|
|
self.assertEqual(str(float("-nan")), "nan")
|
|
|
|
self.assertRaises(ValueError, float, "nana")
|
|
self.assertRaises(ValueError, float, "+nana")
|
|
self.assertRaises(ValueError, float, "-nana")
|
|
self.assertRaises(ValueError, float, "na")
|
|
self.assertRaises(ValueError, float, "+na")
|
|
self.assertRaises(ValueError, float, "-na")
|
|
|
|
def test_nan_as_str(self):
|
|
self.assertEqual(repr(1e300 * 1e300 * 0), "nan")
|
|
self.assertEqual(repr(-1e300 * 1e300 * 0), "nan")
|
|
|
|
self.assertEqual(str(1e300 * 1e300 * 0), "nan")
|
|
self.assertEqual(str(-1e300 * 1e300 * 0), "nan")
|
|
|
|
def notest_float_nan(self):
|
|
self.assertTrue(NAN.is_nan())
|
|
self.assertFalse(INF.is_nan())
|
|
self.assertFalse((0.).is_nan())
|
|
|
|
def notest_float_inf(self):
|
|
self.assertTrue(INF.is_inf())
|
|
self.assertFalse(NAN.is_inf())
|
|
self.assertFalse((0.).is_inf())
|
|
|
|
fromHex = float.fromhex
|
|
toHex = float.hex
|
|
class HexFloatTestCase(unittest.TestCase):
|
|
MAX = fromHex('0x.fffffffffffff8p+1024') # max normal
|
|
MIN = fromHex('0x1p-1022') # min normal
|
|
TINY = fromHex('0x0.0000000000001p-1022') # min subnormal
|
|
EPS = fromHex('0x0.0000000000001p0') # diff between 1.0 and next float up
|
|
|
|
def identical(self, x, y):
|
|
# check that floats x and y are identical, or that both
|
|
# are NaNs
|
|
if isnan(x) or isnan(y):
|
|
if isnan(x) == isnan(y):
|
|
return
|
|
elif x == y and (x != 0.0 or copysign(1.0, x) == copysign(1.0, y)):
|
|
return
|
|
self.fail('%r not identical to %r' % (x, y))
|
|
|
|
def test_ends(self):
|
|
self.identical(self.MIN, ldexp(1.0, -1022))
|
|
self.identical(self.TINY, ldexp(1.0, -1074))
|
|
self.identical(self.EPS, ldexp(1.0, -52))
|
|
self.identical(self.MAX, 2.*(ldexp(1.0, 1023) - ldexp(1.0, 970)))
|
|
|
|
def test_invalid_inputs(self):
|
|
invalid_inputs = [
|
|
'infi', # misspelt infinities and nans
|
|
'-Infinit',
|
|
'++inf',
|
|
'-+Inf',
|
|
'--nan',
|
|
'+-NaN',
|
|
'snan',
|
|
'NaNs',
|
|
'nna',
|
|
'an',
|
|
'nf',
|
|
'nfinity',
|
|
'inity',
|
|
'iinity',
|
|
'0xnan',
|
|
'',
|
|
' ',
|
|
'x1.0p0',
|
|
'0xX1.0p0',
|
|
'+ 0x1.0p0', # internal whitespace
|
|
'- 0x1.0p0',
|
|
'0 x1.0p0',
|
|
'0x 1.0p0',
|
|
'0x1 2.0p0',
|
|
'+0x1 .0p0',
|
|
'0x1. 0p0',
|
|
'-0x1.0 1p0',
|
|
'-0x1.0 p0',
|
|
'+0x1.0p +0',
|
|
'0x1.0p -0',
|
|
'0x1.0p 0',
|
|
'+0x1.0p+ 0',
|
|
'-0x1.0p- 0',
|
|
'++0x1.0p-0', # double signs
|
|
'--0x1.0p0',
|
|
'+-0x1.0p+0',
|
|
'-+0x1.0p0',
|
|
'0x1.0p++0',
|
|
'+0x1.0p+-0',
|
|
'-0x1.0p-+0',
|
|
'0x1.0p--0',
|
|
'0x1.0.p0',
|
|
'0x.p0', # no hex digits before or after point
|
|
'0x1,p0', # wrong decimal point character
|
|
'0x1pa',
|
|
u'0x1p\uff10', # fullwidth Unicode digits
|
|
u'\uff10x1p0',
|
|
u'0x\uff11p0',
|
|
u'0x1.\uff10p0',
|
|
'0x1p0 \n 0x2p0',
|
|
'0x1p0\0 0x1p0', # embedded null byte is not end of string
|
|
]
|
|
for x in invalid_inputs:
|
|
try:
|
|
result = fromHex(x)
|
|
except ValueError:
|
|
pass
|
|
else:
|
|
self.fail('Expected float.fromhex(%r) to raise ValueError; '
|
|
'got %r instead' % (x, result))
|
|
|
|
|
|
def test_whitespace(self):
|
|
value_pairs = [
|
|
('inf', INF),
|
|
('-Infinity', -INF),
|
|
('nan', NAN),
|
|
('1.0', 1.0),
|
|
('-0x.2', -0.125),
|
|
('-0.0', -0.0)
|
|
]
|
|
whitespace = [
|
|
'',
|
|
' ',
|
|
'\t',
|
|
'\n',
|
|
'\n \t',
|
|
'\f',
|
|
'\v',
|
|
'\r'
|
|
]
|
|
for inp, expected in value_pairs:
|
|
for lead in whitespace:
|
|
for trail in whitespace:
|
|
got = fromHex(lead + inp + trail)
|
|
self.identical(got, expected)
|
|
|
|
|
|
def test_from_hex(self):
|
|
MIN = self.MIN;
|
|
MAX = self.MAX;
|
|
TINY = self.TINY;
|
|
EPS = self.EPS;
|
|
|
|
# two spellings of infinity, with optional signs; case-insensitive
|
|
self.identical(fromHex('inf'), INF)
|
|
self.identical(fromHex('+Inf'), INF)
|
|
self.identical(fromHex('-INF'), -INF)
|
|
self.identical(fromHex('iNf'), INF)
|
|
self.identical(fromHex('Infinity'), INF)
|
|
self.identical(fromHex('+INFINITY'), INF)
|
|
self.identical(fromHex('-infinity'), -INF)
|
|
self.identical(fromHex('-iNFiNitY'), -INF)
|
|
|
|
# nans with optional sign; case insensitive
|
|
self.identical(fromHex('nan'), NAN)
|
|
self.identical(fromHex('+NaN'), NAN)
|
|
self.identical(fromHex('-NaN'), NAN)
|
|
self.identical(fromHex('-nAN'), NAN)
|
|
|
|
# variations in input format
|
|
self.identical(fromHex('1'), 1.0)
|
|
self.identical(fromHex('+1'), 1.0)
|
|
self.identical(fromHex('1.'), 1.0)
|
|
self.identical(fromHex('1.0'), 1.0)
|
|
self.identical(fromHex('1.0p0'), 1.0)
|
|
self.identical(fromHex('01'), 1.0)
|
|
self.identical(fromHex('01.'), 1.0)
|
|
self.identical(fromHex('0x1'), 1.0)
|
|
self.identical(fromHex('0x1.'), 1.0)
|
|
self.identical(fromHex('0x1.0'), 1.0)
|
|
self.identical(fromHex('+0x1.0'), 1.0)
|
|
self.identical(fromHex('0x1p0'), 1.0)
|
|
self.identical(fromHex('0X1p0'), 1.0)
|
|
self.identical(fromHex('0X1P0'), 1.0)
|
|
self.identical(fromHex('0x1P0'), 1.0)
|
|
self.identical(fromHex('0x1.p0'), 1.0)
|
|
self.identical(fromHex('0x1.0p0'), 1.0)
|
|
self.identical(fromHex('0x.1p4'), 1.0)
|
|
self.identical(fromHex('0x.1p04'), 1.0)
|
|
self.identical(fromHex('0x.1p004'), 1.0)
|
|
self.identical(fromHex('0x1p+0'), 1.0)
|
|
self.identical(fromHex('0x1P-0'), 1.0)
|
|
self.identical(fromHex('+0x1p0'), 1.0)
|
|
self.identical(fromHex('0x01p0'), 1.0)
|
|
self.identical(fromHex('0x1p00'), 1.0)
|
|
self.identical(fromHex(u'0x1p0'), 1.0)
|
|
self.identical(fromHex(' 0x1p0 '), 1.0)
|
|
self.identical(fromHex('\n 0x1p0'), 1.0)
|
|
self.identical(fromHex('0x1p0 \t'), 1.0)
|
|
self.identical(fromHex('0xap0'), 10.0)
|
|
self.identical(fromHex('0xAp0'), 10.0)
|
|
self.identical(fromHex('0xaP0'), 10.0)
|
|
self.identical(fromHex('0xAP0'), 10.0)
|
|
self.identical(fromHex('0xbep0'), 190.0)
|
|
self.identical(fromHex('0xBep0'), 190.0)
|
|
self.identical(fromHex('0xbEp0'), 190.0)
|
|
self.identical(fromHex('0XBE0P-4'), 190.0)
|
|
self.identical(fromHex('0xBEp0'), 190.0)
|
|
self.identical(fromHex('0xB.Ep4'), 190.0)
|
|
self.identical(fromHex('0x.BEp8'), 190.0)
|
|
self.identical(fromHex('0x.0BEp12'), 190.0)
|
|
|
|
# moving the point around
|
|
pi = fromHex('0x1.921fb54442d18p1')
|
|
self.identical(fromHex('0x.006487ed5110b46p11'), pi)
|
|
self.identical(fromHex('0x.00c90fdaa22168cp10'), pi)
|
|
self.identical(fromHex('0x.01921fb54442d18p9'), pi)
|
|
self.identical(fromHex('0x.03243f6a8885a3p8'), pi)
|
|
self.identical(fromHex('0x.06487ed5110b46p7'), pi)
|
|
self.identical(fromHex('0x.0c90fdaa22168cp6'), pi)
|
|
self.identical(fromHex('0x.1921fb54442d18p5'), pi)
|
|
self.identical(fromHex('0x.3243f6a8885a3p4'), pi)
|
|
self.identical(fromHex('0x.6487ed5110b46p3'), pi)
|
|
self.identical(fromHex('0x.c90fdaa22168cp2'), pi)
|
|
self.identical(fromHex('0x1.921fb54442d18p1'), pi)
|
|
self.identical(fromHex('0x3.243f6a8885a3p0'), pi)
|
|
self.identical(fromHex('0x6.487ed5110b46p-1'), pi)
|
|
self.identical(fromHex('0xc.90fdaa22168cp-2'), pi)
|
|
self.identical(fromHex('0x19.21fb54442d18p-3'), pi)
|
|
self.identical(fromHex('0x32.43f6a8885a3p-4'), pi)
|
|
self.identical(fromHex('0x64.87ed5110b46p-5'), pi)
|
|
self.identical(fromHex('0xc9.0fdaa22168cp-6'), pi)
|
|
self.identical(fromHex('0x192.1fb54442d18p-7'), pi)
|
|
self.identical(fromHex('0x324.3f6a8885a3p-8'), pi)
|
|
self.identical(fromHex('0x648.7ed5110b46p-9'), pi)
|
|
self.identical(fromHex('0xc90.fdaa22168cp-10'), pi)
|
|
self.identical(fromHex('0x1921.fb54442d18p-11'), pi)
|
|
# ...
|
|
self.identical(fromHex('0x1921fb54442d1.8p-47'), pi)
|
|
self.identical(fromHex('0x3243f6a8885a3p-48'), pi)
|
|
self.identical(fromHex('0x6487ed5110b46p-49'), pi)
|
|
self.identical(fromHex('0xc90fdaa22168cp-50'), pi)
|
|
self.identical(fromHex('0x1921fb54442d18p-51'), pi)
|
|
self.identical(fromHex('0x3243f6a8885a30p-52'), pi)
|
|
self.identical(fromHex('0x6487ed5110b460p-53'), pi)
|
|
self.identical(fromHex('0xc90fdaa22168c0p-54'), pi)
|
|
self.identical(fromHex('0x1921fb54442d180p-55'), pi)
|
|
|
|
|
|
# results that should overflow...
|
|
self.assertRaises(OverflowError, fromHex, '-0x1p1024')
|
|
self.assertRaises(OverflowError, fromHex, '0x1p+1025')
|
|
self.assertRaises(OverflowError, fromHex, '+0X1p1030')
|
|
self.assertRaises(OverflowError, fromHex, '-0x1p+1100')
|
|
self.assertRaises(OverflowError, fromHex, '0X1p123456789123456789')
|
|
self.assertRaises(OverflowError, fromHex, '+0X.8p+1025')
|
|
self.assertRaises(OverflowError, fromHex, '+0x0.8p1025')
|
|
self.assertRaises(OverflowError, fromHex, '-0x0.4p1026')
|
|
self.assertRaises(OverflowError, fromHex, '0X2p+1023')
|
|
self.assertRaises(OverflowError, fromHex, '0x2.p1023')
|
|
self.assertRaises(OverflowError, fromHex, '-0x2.0p+1023')
|
|
self.assertRaises(OverflowError, fromHex, '+0X4p+1022')
|
|
self.assertRaises(OverflowError, fromHex, '0x1.ffffffffffffffp+1023')
|
|
self.assertRaises(OverflowError, fromHex, '-0X1.fffffffffffff9p1023')
|
|
self.assertRaises(OverflowError, fromHex, '0X1.fffffffffffff8p1023')
|
|
self.assertRaises(OverflowError, fromHex, '+0x3.fffffffffffffp1022')
|
|
self.assertRaises(OverflowError, fromHex, '0x3fffffffffffffp+970')
|
|
self.assertRaises(OverflowError, fromHex, '0x10000000000000000p960')
|
|
self.assertRaises(OverflowError, fromHex, '-0Xffffffffffffffffp960')
|
|
|
|
# ...and those that round to +-max float
|
|
self.identical(fromHex('+0x1.fffffffffffffp+1023'), MAX)
|
|
self.identical(fromHex('-0X1.fffffffffffff7p1023'), -MAX)
|
|
self.identical(fromHex('0X1.fffffffffffff7fffffffffffffp1023'), MAX)
|
|
|
|
# zeros
|
|
self.identical(fromHex('0x0p0'), 0.0)
|
|
self.identical(fromHex('0x0p1000'), 0.0)
|
|
self.identical(fromHex('-0x0p1023'), -0.0)
|
|
self.identical(fromHex('0X0p1024'), 0.0)
|
|
self.identical(fromHex('-0x0p1025'), -0.0)
|
|
self.identical(fromHex('0X0p2000'), 0.0)
|
|
self.identical(fromHex('0x0p123456789123456789'), 0.0)
|
|
self.identical(fromHex('-0X0p-0'), -0.0)
|
|
self.identical(fromHex('-0X0p-1000'), -0.0)
|
|
self.identical(fromHex('0x0p-1023'), 0.0)
|
|
self.identical(fromHex('-0X0p-1024'), -0.0)
|
|
self.identical(fromHex('-0x0p-1025'), -0.0)
|
|
self.identical(fromHex('-0x0p-1072'), -0.0)
|
|
self.identical(fromHex('0X0p-1073'), 0.0)
|
|
self.identical(fromHex('-0x0p-1074'), -0.0)
|
|
self.identical(fromHex('0x0p-1075'), 0.0)
|
|
self.identical(fromHex('0X0p-1076'), 0.0)
|
|
self.identical(fromHex('-0X0p-2000'), -0.0)
|
|
self.identical(fromHex('-0x0p-123456789123456789'), -0.0)
|
|
|
|
# values that should underflow to 0
|
|
self.identical(fromHex('0X1p-1075'), 0.0)
|
|
self.identical(fromHex('-0X1p-1075'), -0.0)
|
|
self.identical(fromHex('-0x1p-123456789123456789'), -0.0)
|
|
self.identical(fromHex('0x1.00000000000000001p-1075'), TINY)
|
|
self.identical(fromHex('-0x1.1p-1075'), -TINY)
|
|
self.identical(fromHex('0x1.fffffffffffffffffp-1075'), TINY)
|
|
|
|
# check round-half-even is working correctly near 0 ...
|
|
self.identical(fromHex('0x1p-1076'), 0.0)
|
|
self.identical(fromHex('0X2p-1076'), 0.0)
|
|
self.identical(fromHex('0X3p-1076'), TINY)
|
|
self.identical(fromHex('0x4p-1076'), TINY)
|
|
self.identical(fromHex('0X5p-1076'), TINY)
|
|
self.identical(fromHex('0X6p-1076'), 2*TINY)
|
|
self.identical(fromHex('0x7p-1076'), 2*TINY)
|
|
self.identical(fromHex('0X8p-1076'), 2*TINY)
|
|
self.identical(fromHex('0X9p-1076'), 2*TINY)
|
|
self.identical(fromHex('0xap-1076'), 2*TINY)
|
|
self.identical(fromHex('0Xbp-1076'), 3*TINY)
|
|
self.identical(fromHex('0xcp-1076'), 3*TINY)
|
|
self.identical(fromHex('0Xdp-1076'), 3*TINY)
|
|
self.identical(fromHex('0Xep-1076'), 4*TINY)
|
|
self.identical(fromHex('0xfp-1076'), 4*TINY)
|
|
self.identical(fromHex('0x10p-1076'), 4*TINY)
|
|
self.identical(fromHex('-0x1p-1076'), -0.0)
|
|
self.identical(fromHex('-0X2p-1076'), -0.0)
|
|
self.identical(fromHex('-0x3p-1076'), -TINY)
|
|
self.identical(fromHex('-0X4p-1076'), -TINY)
|
|
self.identical(fromHex('-0x5p-1076'), -TINY)
|
|
self.identical(fromHex('-0x6p-1076'), -2*TINY)
|
|
self.identical(fromHex('-0X7p-1076'), -2*TINY)
|
|
self.identical(fromHex('-0X8p-1076'), -2*TINY)
|
|
self.identical(fromHex('-0X9p-1076'), -2*TINY)
|
|
self.identical(fromHex('-0Xap-1076'), -2*TINY)
|
|
self.identical(fromHex('-0xbp-1076'), -3*TINY)
|
|
self.identical(fromHex('-0xcp-1076'), -3*TINY)
|
|
self.identical(fromHex('-0Xdp-1076'), -3*TINY)
|
|
self.identical(fromHex('-0xep-1076'), -4*TINY)
|
|
self.identical(fromHex('-0Xfp-1076'), -4*TINY)
|
|
self.identical(fromHex('-0X10p-1076'), -4*TINY)
|
|
|
|
# ... and near MIN ...
|
|
self.identical(fromHex('0x0.ffffffffffffd6p-1022'), MIN-3*TINY)
|
|
self.identical(fromHex('0x0.ffffffffffffd8p-1022'), MIN-2*TINY)
|
|
self.identical(fromHex('0x0.ffffffffffffdap-1022'), MIN-2*TINY)
|
|
self.identical(fromHex('0x0.ffffffffffffdcp-1022'), MIN-2*TINY)
|
|
self.identical(fromHex('0x0.ffffffffffffdep-1022'), MIN-2*TINY)
|
|
self.identical(fromHex('0x0.ffffffffffffe0p-1022'), MIN-2*TINY)
|
|
self.identical(fromHex('0x0.ffffffffffffe2p-1022'), MIN-2*TINY)
|
|
self.identical(fromHex('0x0.ffffffffffffe4p-1022'), MIN-2*TINY)
|
|
self.identical(fromHex('0x0.ffffffffffffe6p-1022'), MIN-2*TINY)
|
|
self.identical(fromHex('0x0.ffffffffffffe8p-1022'), MIN-2*TINY)
|
|
self.identical(fromHex('0x0.ffffffffffffeap-1022'), MIN-TINY)
|
|
self.identical(fromHex('0x0.ffffffffffffecp-1022'), MIN-TINY)
|
|
self.identical(fromHex('0x0.ffffffffffffeep-1022'), MIN-TINY)
|
|
self.identical(fromHex('0x0.fffffffffffff0p-1022'), MIN-TINY)
|
|
self.identical(fromHex('0x0.fffffffffffff2p-1022'), MIN-TINY)
|
|
self.identical(fromHex('0x0.fffffffffffff4p-1022'), MIN-TINY)
|
|
self.identical(fromHex('0x0.fffffffffffff6p-1022'), MIN-TINY)
|
|
self.identical(fromHex('0x0.fffffffffffff8p-1022'), MIN)
|
|
self.identical(fromHex('0x0.fffffffffffffap-1022'), MIN)
|
|
self.identical(fromHex('0x0.fffffffffffffcp-1022'), MIN)
|
|
self.identical(fromHex('0x0.fffffffffffffep-1022'), MIN)
|
|
self.identical(fromHex('0x1.00000000000000p-1022'), MIN)
|
|
self.identical(fromHex('0x1.00000000000002p-1022'), MIN)
|
|
self.identical(fromHex('0x1.00000000000004p-1022'), MIN)
|
|
self.identical(fromHex('0x1.00000000000006p-1022'), MIN)
|
|
self.identical(fromHex('0x1.00000000000008p-1022'), MIN)
|
|
self.identical(fromHex('0x1.0000000000000ap-1022'), MIN+TINY)
|
|
self.identical(fromHex('0x1.0000000000000cp-1022'), MIN+TINY)
|
|
self.identical(fromHex('0x1.0000000000000ep-1022'), MIN+TINY)
|
|
self.identical(fromHex('0x1.00000000000010p-1022'), MIN+TINY)
|
|
self.identical(fromHex('0x1.00000000000012p-1022'), MIN+TINY)
|
|
self.identical(fromHex('0x1.00000000000014p-1022'), MIN+TINY)
|
|
self.identical(fromHex('0x1.00000000000016p-1022'), MIN+TINY)
|
|
self.identical(fromHex('0x1.00000000000018p-1022'), MIN+2*TINY)
|
|
|
|
# ... and near 1.0.
|
|
self.identical(fromHex('0x0.fffffffffffff0p0'), 1.0-EPS)
|
|
self.identical(fromHex('0x0.fffffffffffff1p0'), 1.0-EPS)
|
|
self.identical(fromHex('0X0.fffffffffffff2p0'), 1.0-EPS)
|
|
self.identical(fromHex('0x0.fffffffffffff3p0'), 1.0-EPS)
|
|
self.identical(fromHex('0X0.fffffffffffff4p0'), 1.0-EPS)
|
|
self.identical(fromHex('0X0.fffffffffffff5p0'), 1.0-EPS/2)
|
|
self.identical(fromHex('0X0.fffffffffffff6p0'), 1.0-EPS/2)
|
|
self.identical(fromHex('0x0.fffffffffffff7p0'), 1.0-EPS/2)
|
|
self.identical(fromHex('0x0.fffffffffffff8p0'), 1.0-EPS/2)
|
|
self.identical(fromHex('0X0.fffffffffffff9p0'), 1.0-EPS/2)
|
|
self.identical(fromHex('0X0.fffffffffffffap0'), 1.0-EPS/2)
|
|
self.identical(fromHex('0x0.fffffffffffffbp0'), 1.0-EPS/2)
|
|
self.identical(fromHex('0X0.fffffffffffffcp0'), 1.0)
|
|
self.identical(fromHex('0x0.fffffffffffffdp0'), 1.0)
|
|
self.identical(fromHex('0X0.fffffffffffffep0'), 1.0)
|
|
self.identical(fromHex('0x0.ffffffffffffffp0'), 1.0)
|
|
self.identical(fromHex('0X1.00000000000000p0'), 1.0)
|
|
self.identical(fromHex('0X1.00000000000001p0'), 1.0)
|
|
self.identical(fromHex('0x1.00000000000002p0'), 1.0)
|
|
self.identical(fromHex('0X1.00000000000003p0'), 1.0)
|
|
self.identical(fromHex('0x1.00000000000004p0'), 1.0)
|
|
self.identical(fromHex('0X1.00000000000005p0'), 1.0)
|
|
self.identical(fromHex('0X1.00000000000006p0'), 1.0)
|
|
self.identical(fromHex('0X1.00000000000007p0'), 1.0)
|
|
self.identical(fromHex('0x1.00000000000007ffffffffffffffffffffp0'),
|
|
1.0)
|
|
self.identical(fromHex('0x1.00000000000008p0'), 1.0)
|
|
self.identical(fromHex('0x1.00000000000008000000000000000001p0'),
|
|
1+EPS)
|
|
self.identical(fromHex('0X1.00000000000009p0'), 1.0+EPS)
|
|
self.identical(fromHex('0x1.0000000000000ap0'), 1.0+EPS)
|
|
self.identical(fromHex('0x1.0000000000000bp0'), 1.0+EPS)
|
|
self.identical(fromHex('0X1.0000000000000cp0'), 1.0+EPS)
|
|
self.identical(fromHex('0x1.0000000000000dp0'), 1.0+EPS)
|
|
self.identical(fromHex('0x1.0000000000000ep0'), 1.0+EPS)
|
|
self.identical(fromHex('0X1.0000000000000fp0'), 1.0+EPS)
|
|
self.identical(fromHex('0x1.00000000000010p0'), 1.0+EPS)
|
|
self.identical(fromHex('0X1.00000000000011p0'), 1.0+EPS)
|
|
self.identical(fromHex('0x1.00000000000012p0'), 1.0+EPS)
|
|
self.identical(fromHex('0X1.00000000000013p0'), 1.0+EPS)
|
|
self.identical(fromHex('0X1.00000000000014p0'), 1.0+EPS)
|
|
self.identical(fromHex('0x1.00000000000015p0'), 1.0+EPS)
|
|
self.identical(fromHex('0x1.00000000000016p0'), 1.0+EPS)
|
|
self.identical(fromHex('0X1.00000000000017p0'), 1.0+EPS)
|
|
self.identical(fromHex('0x1.00000000000017ffffffffffffffffffffp0'),
|
|
1.0+EPS)
|
|
self.identical(fromHex('0x1.00000000000018p0'), 1.0+2*EPS)
|
|
self.identical(fromHex('0X1.00000000000018000000000000000001p0'),
|
|
1.0+2*EPS)
|
|
self.identical(fromHex('0x1.00000000000019p0'), 1.0+2*EPS)
|
|
self.identical(fromHex('0X1.0000000000001ap0'), 1.0+2*EPS)
|
|
self.identical(fromHex('0X1.0000000000001bp0'), 1.0+2*EPS)
|
|
self.identical(fromHex('0x1.0000000000001cp0'), 1.0+2*EPS)
|
|
self.identical(fromHex('0x1.0000000000001dp0'), 1.0+2*EPS)
|
|
self.identical(fromHex('0x1.0000000000001ep0'), 1.0+2*EPS)
|
|
self.identical(fromHex('0X1.0000000000001fp0'), 1.0+2*EPS)
|
|
self.identical(fromHex('0x1.00000000000020p0'), 1.0+2*EPS)
|
|
|
|
def test_roundtrip(self):
|
|
def roundtrip(x):
|
|
return fromHex(toHex(x))
|
|
|
|
for x in [NAN, INF, self.MAX, self.MIN, self.MIN-self.TINY, self.TINY, 0.0]:
|
|
self.identical(x, roundtrip(x))
|
|
self.identical(-x, roundtrip(-x))
|
|
|
|
# fromHex(toHex(x)) should exactly recover x, for any non-NaN float x.
|
|
import random
|
|
for i in xrange(10000):
|
|
e = random.randrange(-1200, 1200)
|
|
m = random.random()
|
|
s = random.choice([1.0, -1.0])
|
|
try:
|
|
x = s*ldexp(m, e)
|
|
except OverflowError:
|
|
pass
|
|
else:
|
|
self.identical(x, fromHex(toHex(x)))
|
|
|
|
class StrtodTestCase(unittest.TestCase):
|
|
def check_string(self, s):
|
|
expected = strtod(s)
|
|
try:
|
|
fs = float(s)
|
|
except OverflowError:
|
|
got = '-inf' if s[0] == '-' else 'inf'
|
|
else:
|
|
got = fs.hex()
|
|
self.assertEqual(expected, got,
|
|
"Incorrectly rounded str->float conversion for "
|
|
"{}: expected {}, got {}".format(s, expected, got))
|
|
|
|
@unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short',
|
|
"applies only when using short float repr style")
|
|
def test_bug7632(self):
|
|
# check a few particular values that gave incorrectly rounded
|
|
# results with previous versions of dtoa.c
|
|
test_strings = [
|
|
'94393431193180696942841837085033647913224148539854e-358',
|
|
'12579816049008305546974391768996369464963024663104e-357',
|
|
'17489628565202117263145367596028389348922981857013e-357',
|
|
'18487398785991994634182916638542680759613590482273e-357',
|
|
'32002864200581033134358724675198044527469366773928e-358',
|
|
'73608278998966969345824653500136787876436005957953e-358',
|
|
'64774478836417299491718435234611299336288082136054e-358',
|
|
'13704940134126574534878641876947980878824688451169e-357',
|
|
'46697445774047060960624497964425416610480524760471e-358',
|
|
]
|
|
for s in test_strings:
|
|
self.check_string(s)
|
|
|
|
|
|
def test_main():
|
|
test_support.run_unittest(
|
|
GeneralFloatCases,
|
|
FormatFunctionsTestCase,
|
|
UnknownFormatTestCase,
|
|
IEEEFormatTestCase,
|
|
ReprTestCase,
|
|
RoundTestCase,
|
|
InfNanTest,
|
|
HexFloatTestCase,
|
|
StrtodTestCase,
|
|
)
|
|
|
|
if __name__ == '__main__':
|
|
test_main()
|