Commits

Philip Jenvey  committed c0aed73 Merge

merge default

  • Participants
  • Parent commits c0fb337, 1fce20d
  • Branches py3k

Comments (0)

Files changed (11)

File pypy/module/_cffi_backend/ctypeenum.py

                 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):

File pypy/module/_cffi_backend/ctypeobj.py

         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')
     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(
     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

File pypy/module/_cffi_backend/test/_backend_test_c.py

     # '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))

File pypy/module/math/test/test_direct.py

         ('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 = [

File pypy/module/math/test/test_math.py

             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]))

File pypy/module/micronumpy/test/test_complex.py

         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

File pypy/module/select/test/test_select.py

         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:
             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

File pypy/rlib/rfloat.py

     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
 
     # 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:
     # 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
 
 # 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
         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

File pypy/rpython/lltypesystem/module/ll_math.py

     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)
 

File pypy/rpython/test/test_rfloat.py

             # 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):
 
 
 
 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')

File pypy/translator/platform/linux.py

                  + 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 = ()