Author: Philip Jenvey <[email protected]>
Branch: py3k
Changeset: r59426:c0aed73821fb
Date: 2012-12-14 16:12 -0800
http://bitbucket.org/pypy/pypy/changeset/c0aed73821fb/
Log: merge default
diff --git a/pypy/module/_cffi_backend/ctypeenum.py
b/pypy/module/_cffi_backend/ctypeenum.py
--- a/pypy/module/_cffi_backend/ctypeenum.py
+++ b/pypy/module/_cffi_backend/ctypeenum.py
@@ -37,6 +37,13 @@
space.setitem(w_dct, space.wrap(enumvalue),
space.wrap(enumerator))
return w_dct
+ if attrchar == 'R': # relements
+ space = self.space
+ w_dct = space.newdict()
+ for enumerator, enumvalue in self.enumerators2values.iteritems():
+ space.setitem(w_dct, space.wrap(enumerator),
+ space.wrap(enumvalue))
+ return w_dct
return W_CTypePrimitiveSigned._fget(self, attrchar)
def string(self, cdataobj, maxlen):
diff --git a/pypy/module/_cffi_backend/ctypeobj.py
b/pypy/module/_cffi_backend/ctypeobj.py
--- a/pypy/module/_cffi_backend/ctypeobj.py
+++ b/pypy/module/_cffi_backend/ctypeobj.py
@@ -188,7 +188,7 @@
if attrchar == 'c': # cname
return space.wrap(self.name)
raise operationerrfmt(space.w_AttributeError,
- "cdata '%s' has no such attribute",
+ "ctype '%s' has no such attribute",
self.name)
def fget_kind(self, space): return self._fget('k')
@@ -201,6 +201,7 @@
def fget_ellipsis(self, space): return self._fget('E')
def fget_abi(self, space): return self._fget('A')
def fget_elements(self, space): return self._fget('e')
+ def fget_relements(self, space):return self._fget('R')
W_CType.typedef = TypeDef(
@@ -218,6 +219,8 @@
ellipsis = GetSetProperty(W_CType.fget_ellipsis, doc="function has '...'"),
abi = GetSetProperty(W_CType.fget_abi, doc="function ABI"),
elements = GetSetProperty(W_CType.fget_elements, doc="enum elements"),
+ relements = GetSetProperty(W_CType.fget_relements,
+ doc="enum elements, reversed"),
__dir__ = interp2app(W_CType.dir),
)
W_CType.typedef.acceptable_as_base_class = False
diff --git a/pypy/module/_cffi_backend/test/_backend_test_c.py
b/pypy/module/_cffi_backend/test/_backend_test_c.py
--- a/pypy/module/_cffi_backend/test/_backend_test_c.py
+++ b/pypy/module/_cffi_backend/test/_backend_test_c.py
@@ -1272,6 +1272,10 @@
# 'elements' is not the real dict, but merely a copy
BEnum.elements[2] = '??'
assert BEnum.elements == {-20: 'ab', 0: 'def', 1: 'c'}
+ #
+ BEnum = new_enum_type("bar", ('ab', 'cd'), (5, 5))
+ assert BEnum.elements == {5: 'ab'}
+ assert BEnum.relements == {'ab': 5, 'cd': 5}
def test_cast_to_enum():
BEnum = new_enum_type("foo", ('def', 'c', 'ab'), (0, 1, -20))
diff --git a/pypy/module/math/test/test_direct.py
b/pypy/module/math/test/test_direct.py
--- a/pypy/module/math/test/test_direct.py
+++ b/pypy/module/math/test/test_direct.py
@@ -72,9 +72,10 @@
('exp', (9999.9,), OverflowError),
('pow', (10.0, 40000.0), OverflowError),
('ldexp', (10.0, 40000), OverflowError),
- ('log', (0.0,), ValueError),
+ ('log', (0.0,), ValueError), #cpython does it this way
+ ('log1p', (-1.0,), OverflowError),
('log', (-1.,), ValueError),
- ('log10', (0.0,), ValueError),
+ ('log10', (0.0,), ValueError), #cpython does it this way
]
INFCASES = [
diff --git a/pypy/module/math/test/test_math.py
b/pypy/module/math/test/test_math.py
--- a/pypy/module/math/test/test_math.py
+++ b/pypy/module/math/test/test_math.py
@@ -17,7 +17,8 @@
if type(expected) is type and issubclass(expected, Exception):
expected = getattr(space, "w_%s" % expected.__name__)
elif callable(expected):
- expected = cls.make_callable_wrapper(expected)
+ if not cls.runappdirect:
+ expected = cls.make_callable_wrapper(expected)
else:
expected = space.wrap(expected)
cases.append(space.newtuple([space.wrap(a), space.wrap(b),
expected]))
diff --git a/pypy/module/micronumpy/test/test_complex.py
b/pypy/module/micronumpy/test/test_complex.py
--- a/pypy/module/micronumpy/test/test_complex.py
+++ b/pypy/module/micronumpy/test/test_complex.py
@@ -94,30 +94,42 @@
cls.w_testcases128 = cls.space.wrap(list(parse_testfile(fname128)))
cls.w_testcases64 = cls.space.wrap(list(parse_testfile(fname64)))
- def cls_c_pow(space, args_w):
- try:
- retVal = c_pow(*map(space.unwrap, args_w))
- return space.wrap(retVal)
- except ValueError, e:
- if option.runappdirect:
- raise
- raise OperationError(cls.space.w_ValueError,
- cls.space.wrap(e.message))
- cls.w_c_pow = cls.space.wrap(interp2app(cls_c_pow))
cls.w_runAppDirect = cls.space.wrap(option.runappdirect)
cls.w_isWindows = cls.space.wrap(os.name == 'nt')
- def cls_rAlmostEqual(space, __args__):
- args, kwargs = __args__.unpack()
- args = map(space.unwrap, args)
- kwargs = dict([
- (k, space.unwrap(v))
- for k, v in kwargs.iteritems()
- ])
- if '__pypy__' not in sys.builtin_module_names:
- kwargs['isnumpy'] = True
- return space.wrap(rAlmostEqual(*args, **kwargs))
- cls.w_rAlmostEqual = cls.space.wrap(interp2app(cls_rAlmostEqual))
+ if cls.runappdirect:
+ def cls_rAlmostEqual(space, *args, **kwargs):
+ return rAlmostEqual(*args, **kwargs)
+ cls.w_rAlmostEqual = cls.space.wrap(cls_rAlmostEqual)
+ def cls_c_pow(space, *args):
+ return c_pow(*args)
+ cls.w_c_pow = cls.space.wrap(cls_c_pow)
+ else:
+ def cls_rAlmostEqual(space, __args__):
+ args, kwargs = __args__.unpack()
+ args = map(space.unwrap, args)
+ kwargs = dict([
+ (k, space.unwrap(v))
+ for k, v in kwargs.iteritems()
+ ])
+ if '__pypy__' not in sys.builtin_module_names:
+ kwargs['isnumpy'] = True
+ return space.wrap(rAlmostEqual(*args, **kwargs))
+ cls.w_rAlmostEqual = cls.space.wrap(interp2app(cls_rAlmostEqual))
+ def cls_c_pow(space, args_w):
+ try:
+ retVal = c_pow(*map(space.unwrap, args_w))
+ return space.wrap(retVal)
+ except ZeroDivisionError, e:
+ raise OperationError(cls.space.w_ZeroDivisionError,
+ cls.space.wrap(e.message))
+ except OverflowError, e:
+ raise OperationError(cls.space.w_OverflowError,
+ cls.space.wrap(e.message))
+ except ValueError, e:
+ raise OperationError(cls.space.w_ValueError,
+ cls.space.wrap(e.message))
+ cls.w_c_pow = cls.space.wrap(interp2app(cls_c_pow))
def test_fabs(self):
from _numpypy import fabs, complex128
diff --git a/pypy/module/select/test/test_select.py
b/pypy/module/select/test/test_select.py
--- a/pypy/module/select/test/test_select.py
+++ b/pypy/module/select/test/test_select.py
@@ -272,6 +272,7 @@
w_import = space.getattr(space.builtin, space.wrap("__import__"))
w_socketmod = space.call_function(w_import, space.wrap("socket"))
cls.w_sock = cls.space.call_method(w_socketmod, "socket")
+ cls.w_sock_err = space.getattr(w_socketmod, space.wrap("error"))
try_ports = [1023] + range(20000, 30000, 437)
for port in try_ports:
@@ -279,11 +280,8 @@
cls.w_sockaddress = space.wrap(('127.0.0.1', port))
try:
space.call_method(cls.w_sock, "bind", cls.w_sockaddress)
- print 'works'
break
- except OperationError, e: # should get a "Permission denied"
- if not e.match(space, space.getattr(w_socketmod,
space.wrap("error"))):
- raise
+ except cls.w_sock_err, e: # should get a "Permission denied"
print e
else:
raise e
diff --git a/pypy/rlib/rfloat.py b/pypy/rlib/rfloat.py
--- a/pypy/rlib/rfloat.py
+++ b/pypy/rlib/rfloat.py
@@ -170,13 +170,17 @@
result = formatd(value, tp, precision, flags)
return result, special
-def round_double(value, ndigits):
+def round_double(value, ndigits, half_even=False):
+ """Round a float half away from zero.
+
+ Specify half_even=True to round half even instead.
+ """
if USE_SHORT_FLOAT_REPR:
- return round_double_short_repr(value, ndigits)
+ return round_double_short_repr(value, ndigits, half_even)
else:
- return round_double_fallback_repr(value, ndigits)
+ return round_double_fallback_repr(value, ndigits, half_even)
-def round_double_short_repr(value, ndigits):
+def round_double_short_repr(value, ndigits, half_even):
# The basic idea is very simple: convert and round the double to
# a decimal string using _Py_dg_dtoa, then convert that decimal
# string back to a double with _Py_dg_strtod. There's one minor
@@ -209,7 +213,7 @@
# determine whether this is a halfway case.
halfway_case = 0
- if expo == -ndigits - 1:
+ if not half_even and expo == -ndigits - 1:
if ndigits >= 0:
halfway_case = 1
elif ndigits >= -22:
@@ -224,7 +228,7 @@
# round to a decimal string; use an extra place for halfway case
strvalue = formatd(value, 'f', ndigits + halfway_case)
- if halfway_case:
+ if not half_even and halfway_case:
buf = [c for c in strvalue]
if ndigits >= 0:
endpos = len(buf) - 1
@@ -263,7 +267,7 @@
# fallback version, to be used when correctly rounded
# binary<->decimal conversions aren't available
-def round_double_fallback_repr(value, ndigits):
+def round_double_fallback_repr(value, ndigits, half_even):
if ndigits >= 0:
if ndigits > 22:
# pow1 and pow2 are each safe from overflow, but
@@ -284,12 +288,17 @@
pow2 = 1.0 # unused; for translation
y = value / pow1
- if y >= 0.0:
- z = math.floor(y + 0.5)
+ if half_even:
+ z = round_away(y)
+ if math.fabs(y - z) == 0.5:
+ z = 2.0 * round_away(y / 2.0)
else:
- z = math.ceil(y - 0.5)
- if math.fabs(y-z) == 1.0: # obscure case, see the test
- z = y
+ if y >= 0.0:
+ z = math.floor(y + 0.5)
+ else:
+ z = math.ceil(y - 0.5)
+ if math.fabs(y - z) == 1.0: # obscure case, see the test
+ z = y
if ndigits >= 0:
z = (z / pow2) / pow1
diff --git a/pypy/rpython/lltypesystem/module/ll_math.py
b/pypy/rpython/lltypesystem/module/ll_math.py
--- a/pypy/rpython/lltypesystem/module/ll_math.py
+++ b/pypy/rpython/lltypesystem/module/ll_math.py
@@ -368,6 +368,8 @@
if x == 0.0:
return x # returns 0.0 or -0.0
if x <= -1.0:
+ if x == -1:
+ raise OverflowError("math range error")
raise ValueError("math domain error")
return math_log1p(x)
diff --git a/pypy/rpython/test/test_rfloat.py b/pypy/rpython/test/test_rfloat.py
--- a/pypy/rpython/test/test_rfloat.py
+++ b/pypy/rpython/test/test_rfloat.py
@@ -215,6 +215,174 @@
# https://bugzilla.novell.com/show_bug.cgi?id=692493
assert not self.interpret(fn, [1e200, 1e200]) # nan
+ def test_break_up_float(self):
+ from pypy.rlib.rfloat import break_up_float
+ assert break_up_float('1') == ('', '1', '', '')
+ assert break_up_float('+1') == ('+', '1', '', '')
+ assert break_up_float('-1') == ('-', '1', '', '')
+
+ assert break_up_float('.5') == ('', '', '5', '')
+
+ assert break_up_float('1.2e3') == ('', '1', '2', '3')
+ assert break_up_float('1.2e+3') == ('', '1', '2', '+3')
+ assert break_up_float('1.2e-3') == ('', '1', '2', '-3')
+
+ # some that will get thrown out on return:
+ assert break_up_float('.') == ('', '', '', '')
+ assert break_up_float('+') == ('+', '', '', '')
+ assert break_up_float('-') == ('-', '', '', '')
+ assert break_up_float('e1') == ('', '', '', '1')
+
+ raises(ValueError, break_up_float, 'e')
+
+ def test_formatd(self):
+ from pypy.rlib.rfloat import formatd
+ def f(x):
+ return formatd(x, 'f', 2, 0)
+ res = self.ll_to_string(self.interpret(f, [10/3.0]))
+ assert res == '3.33'
+
+ def test_formatd_repr(self):
+ from pypy.rlib.rfloat import formatd
+ def f(x):
+ return formatd(x, 'r', 0, 0)
+ res = self.ll_to_string(self.interpret(f, [1.1]))
+ assert res == '1.1'
+
+ def test_formatd_huge(self):
+ from pypy.rlib.rfloat import formatd
+ def f(x):
+ return formatd(x, 'f', 1234, 0)
+ res = self.ll_to_string(self.interpret(f, [1.0]))
+ assert res == '1.' + 1234 * '0'
+
+ def test_formatd_F(self):
+ from pypy.translator.c.test.test_genc import compile
+ from pypy.rlib.rfloat import formatd
+
+ def func(x):
+ # Test the %F format, which is not supported by
+ # the Microsoft's msvcrt library.
+ return formatd(x, 'F', 4)
+
+ f = compile(func, [float])
+ assert f(10/3.0) == '3.3333'
+
+ def test_parts_to_float(self):
+ from pypy.rlib.rfloat import parts_to_float, break_up_float
+ def f(x):
+ if x == 0:
+ s = '1.0'
+ else:
+ s = '1e-100'
+ sign, beforept, afterpt, expt = break_up_float(s)
+ return parts_to_float(sign, beforept, afterpt, expt)
+ res = self.interpret(f, [0])
+ assert res == 1.0
+
+ res = self.interpret(f, [1])
+ assert res == 1e-100
+
+ def test_string_to_float(self):
+ from pypy.rlib.rfloat import rstring_to_float
+ def func(x):
+ if x == 0:
+ s = '1e23'
+ else:
+ s = '-1e23'
+ return rstring_to_float(s)
+
+ assert self.interpret(func, [0]) == 1e23
+ assert self.interpret(func, [1]) == -1e23
+
+ def test_copysign(self):
+ from pypy.rlib.rfloat import copysign
+ assert copysign(1, 1) == 1
+ assert copysign(-1, 1) == 1
+ assert copysign(-1, -1) == -1
+ assert copysign(1, -1) == -1
+ assert copysign(1, -0.) == -1
+
+ def test_round_away(self):
+ from pypy.rlib.rfloat import round_away
+ assert round_away(.1) == 0.
+ assert round_away(.5) == 1.
+ assert round_away(.7) == 1.
+ assert round_away(1.) == 1.
+ assert round_away(-.5) == -1.
+ assert round_away(-.1) == 0.
+ assert round_away(-.7) == -1.
+ assert round_away(0.) == 0.
+
+ def test_round_double(self):
+ from pypy.rlib.rfloat import round_double
+ def almost_equal(x, y):
+ assert round(abs(x-y), 7) == 0
+
+ almost_equal(round_double(0.125, 2), 0.13)
+ almost_equal(round_double(0.375, 2), 0.38)
+ almost_equal(round_double(0.625, 2), 0.63)
+ almost_equal(round_double(0.875, 2), 0.88)
+ almost_equal(round_double(-0.125, 2), -0.13)
+ almost_equal(round_double(-0.375, 2), -0.38)
+ almost_equal(round_double(-0.625, 2), -0.63)
+ almost_equal(round_double(-0.875, 2), -0.88)
+
+ almost_equal(round_double(0.25, 1), 0.3)
+ almost_equal(round_double(0.75, 1), 0.8)
+ almost_equal(round_double(-0.25, 1), -0.3)
+ almost_equal(round_double(-0.75, 1), -0.8)
+
+ round_double(-6.5, 0) == -7.0
+ round_double(-5.5, 0) == -6.0
+ round_double(-1.5, 0) == -2.0
+ round_double(-0.5, 0) == -1.0
+ round_double(0.5, 0) == 1.0
+ round_double(1.5, 0) == 2.0
+ round_double(2.5, 0) == 3.0
+ round_double(3.5, 0) == 4.0
+ round_double(4.5, 0) == 5.0
+ round_double(5.5, 0) == 6.0
+ round_double(6.5, 0) == 7.0
+
+ round_double(-25.0, -1) == -30.0
+ round_double(-15.0, -1) == -20.0
+ round_double(-5.0, -1) == -10.0
+ round_double(5.0, -1) == 10.0
+ round_double(15.0, -1) == 20.0
+ round_double(25.0, -1) == 30.0
+ round_double(35.0, -1) == 40.0
+ round_double(45.0, -1) == 50.0
+ round_double(55.0, -1) == 60.0
+ round_double(65.0, -1) == 70.0
+ round_double(75.0, -1) == 80.0
+ round_double(85.0, -1) == 90.0
+ round_double(95.0, -1) == 100.0
+ round_double(12325.0, -1) == 12330.0
+
+ round_double(350.0, -2) == 400.0
+ round_double(450.0, -2) == 500.0
+
+ almost_equal(round_double(0.5e21, -21), 1e21)
+ almost_equal(round_double(1.5e21, -21), 2e21)
+ almost_equal(round_double(2.5e21, -21), 3e21)
+ almost_equal(round_double(5.5e21, -21), 6e21)
+ almost_equal(round_double(8.5e21, -21), 9e21)
+
+ almost_equal(round_double(-1.5e22, -22), -2e22)
+ almost_equal(round_double(-0.5e22, -22), -1e22)
+ almost_equal(round_double(0.5e22, -22), 1e22)
+ almost_equal(round_double(1.5e22, -22), 2e22)
+
+ def test_round_half_even(self):
+ from pypy.rlib import rfloat
+ for func in (rfloat.round_double_short_repr,
+ rfloat.round_double_fallback_repr):
+ # 2.x behavior
+ assert func(2.5, 0, False) == 3.0
+ # 3.x behavior
+ assert func(2.5, 0, True) == 2.0
+
class TestLLtype(BaseTestRfloat, LLRtypeMixin):
@@ -226,4 +394,15 @@
class TestOOtype(BaseTestRfloat, OORtypeMixin):
- pass
+
+ def test_formatd(self):
+ skip('formatd is broken on ootype')
+
+ def test_formatd_repr(self):
+ skip('formatd is broken on ootype')
+
+ def test_formatd_huge(self):
+ skip('formatd is broken on ootype')
+
+ def test_string_to_float(self):
+ skip('string_to_float is broken on ootype')
diff --git a/pypy/translator/platform/linux.py
b/pypy/translator/platform/linux.py
--- a/pypy/translator/platform/linux.py
+++ b/pypy/translator/platform/linux.py
@@ -13,7 +13,8 @@
+ os.environ.get('LDFLAGS', '').split())
extra_libs = ('-lrt',)
cflags = tuple(
- ['-O3', '-pthread', '-fomit-frame-pointer',
+ ['-Os', # more compact and actually a bit faster
+ '-pthread', '-fomit-frame-pointer',
'-Wall', '-Wno-unused']
+ os.environ.get('CFLAGS', '').split())
standalone_only = ()
_______________________________________________
pypy-commit mailing list
[email protected]
http://mail.python.org/mailman/listinfo/pypy-commit
