Author: Alex Gaynor <[email protected]>
Branch: dynamic-specialized-tuple
Changeset: r53460:2e5657b28f97
Date: 2012-03-13 11:33 -0700
http://bitbucket.org/pypy/pypy/changeset/2e5657b28f97/
Log: merged default in, resolved merge conflicts
diff --git a/pypy/annotation/builtin.py b/pypy/annotation/builtin.py
--- a/pypy/annotation/builtin.py
+++ b/pypy/annotation/builtin.py
@@ -301,7 +301,7 @@
def robjmodel_instantiate(s_clspbc):
assert isinstance(s_clspbc, SomePBC)
clsdef = None
- more_than_one = len(s_clspbc.descriptions)
+ more_than_one = len(s_clspbc.descriptions) > 1
for desc in s_clspbc.descriptions:
cdef = desc.getuniqueclassdef()
if more_than_one:
diff --git a/pypy/annotation/model.py b/pypy/annotation/model.py
--- a/pypy/annotation/model.py
+++ b/pypy/annotation/model.py
@@ -786,12 +786,15 @@
#
# safety check that no-one is trying to make annotation and translation
# faster by providing the -O option to Python.
-try:
- assert False
-except AssertionError:
- pass # fine
-else:
- raise RuntimeError("The annotator relies on 'assert' statements from the\n"
+import os
+if "WINGDB_PYTHON" not in os.environ:
+ # ...but avoiding this boring check in the IDE
+ try:
+ assert False
+ except AssertionError:
+ pass # fine
+ else:
+ raise RuntimeError("The annotator relies on 'assert' statements from
the\n"
"\tannotated program: you cannot run it with 'python
-O'.")
# this has the side-effect of registering the unary and binary operations
diff --git a/pypy/interpreter/astcompiler/test/test_compiler.py
b/pypy/interpreter/astcompiler/test/test_compiler.py
--- a/pypy/interpreter/astcompiler/test/test_compiler.py
+++ b/pypy/interpreter/astcompiler/test/test_compiler.py
@@ -58,7 +58,8 @@
w_res = pyco_expr.exec_host_bytecode(w_dict, w_dict)
res = space.str_w(space.repr(w_res))
if not isinstance(expected, float):
- assert res == repr(expected)
+ noL = lambda expr: expr.replace('L', '')
+ assert noL(res) == noL(repr(expected))
else:
# Float representation can vary a bit between interpreter
# versions, compare the numbers instead.
diff --git a/pypy/interpreter/test/test_compiler.py
b/pypy/interpreter/test/test_compiler.py
--- a/pypy/interpreter/test/test_compiler.py
+++ b/pypy/interpreter/test/test_compiler.py
@@ -794,7 +794,7 @@
def test_tuple_constants(self):
ns = {}
exec "x = (1, 0); y = (1L, 0L)" in ns
- assert isinstance(ns["x"][0], int)
+ assert isinstance(ns["x"][0], (int, long))
assert isinstance(ns["y"][0], long)
def test_division_folding(self):
diff --git a/pypy/module/cpyext/test/test_stringobject.py
b/pypy/module/cpyext/test/test_stringobject.py
--- a/pypy/module/cpyext/test/test_stringobject.py
+++ b/pypy/module/cpyext/test/test_stringobject.py
@@ -105,6 +105,15 @@
)])
assert module.string_as_string("huheduwe") == "huhe"
+ def test_py_string_as_string_None(self):
+ module = self.import_extension('foo', [
+ ("string_None", "METH_VARARGS",
+ '''
+ return PyString_AsString(Py_None);
+ '''
+ )])
+ raises(TypeError, module.string_None)
+
def test_AsStringAndSize(self):
module = self.import_extension('foo', [
("getstring", "METH_NOARGS",
diff --git a/pypy/module/micronumpy/__init__.py
b/pypy/module/micronumpy/__init__.py
--- a/pypy/module/micronumpy/__init__.py
+++ b/pypy/module/micronumpy/__init__.py
@@ -89,6 +89,9 @@
("multiply", "multiply"),
("negative", "negative"),
("not_equal", "not_equal"),
+ ("radians", "radians"),
+ ("degrees", "degrees"),
+ ("deg2rad", "radians"),
("reciprocal", "reciprocal"),
("sign", "sign"),
("sin", "sin"),
@@ -107,6 +110,12 @@
('logical_xor', 'logical_xor'),
('logical_not', 'logical_not'),
('logical_or', 'logical_or'),
+ ('log', 'log'),
+ ('log2', 'log2'),
+ ('log10', 'log10'),
+ ('log1p', 'log1p'),
+ ('power', 'power'),
+ ('floor_divide', 'floor_divide'),
]:
interpleveldefs[exposed] = "interp_ufuncs.get(space).%s" % impl
diff --git a/pypy/module/micronumpy/interp_boxes.py
b/pypy/module/micronumpy/interp_boxes.py
--- a/pypy/module/micronumpy/interp_boxes.py
+++ b/pypy/module/micronumpy/interp_boxes.py
@@ -80,6 +80,7 @@
descr_mul = _binop_impl("multiply")
descr_div = _binop_impl("divide")
descr_truediv = _binop_impl("true_divide")
+ descr_floordiv = _binop_impl("floor_divide")
descr_mod = _binop_impl("mod")
descr_pow = _binop_impl("power")
descr_lshift = _binop_impl("left_shift")
@@ -100,6 +101,7 @@
descr_rmul = _binop_right_impl("multiply")
descr_rdiv = _binop_right_impl("divide")
descr_rtruediv = _binop_right_impl("true_divide")
+ descr_rfloordiv = _binop_right_impl("floor_divide")
descr_rmod = _binop_right_impl("mod")
descr_rpow = _binop_right_impl("power")
descr_rlshift = _binop_right_impl("left_shift")
@@ -208,6 +210,7 @@
__mul__ = interp2app(W_GenericBox.descr_mul),
__div__ = interp2app(W_GenericBox.descr_div),
__truediv__ = interp2app(W_GenericBox.descr_truediv),
+ __floordiv__ = interp2app(W_GenericBox.descr_floordiv),
__mod__ = interp2app(W_GenericBox.descr_mod),
__divmod__ = interp2app(W_GenericBox.descr_divmod),
__pow__ = interp2app(W_GenericBox.descr_pow),
@@ -222,6 +225,7 @@
__rmul__ = interp2app(W_GenericBox.descr_rmul),
__rdiv__ = interp2app(W_GenericBox.descr_rdiv),
__rtruediv__ = interp2app(W_GenericBox.descr_rtruediv),
+ __rfloordiv__ = interp2app(W_GenericBox.descr_rfloordiv),
__rmod__ = interp2app(W_GenericBox.descr_rmod),
__rdivmod__ = interp2app(W_GenericBox.descr_rdivmod),
__rpow__ = interp2app(W_GenericBox.descr_rpow),
diff --git a/pypy/module/micronumpy/interp_numarray.py
b/pypy/module/micronumpy/interp_numarray.py
--- a/pypy/module/micronumpy/interp_numarray.py
+++ b/pypy/module/micronumpy/interp_numarray.py
@@ -102,6 +102,7 @@
descr_mul = _binop_impl("multiply")
descr_div = _binop_impl("divide")
descr_truediv = _binop_impl("true_divide")
+ descr_floordiv = _binop_impl("floor_divide")
descr_mod = _binop_impl("mod")
descr_pow = _binop_impl("power")
descr_lshift = _binop_impl("left_shift")
@@ -136,6 +137,7 @@
descr_rmul = _binop_right_impl("multiply")
descr_rdiv = _binop_right_impl("divide")
descr_rtruediv = _binop_right_impl("true_divide")
+ descr_rfloordiv = _binop_right_impl("floor_divide")
descr_rmod = _binop_right_impl("mod")
descr_rpow = _binop_right_impl("power")
descr_rlshift = _binop_right_impl("left_shift")
@@ -1250,6 +1252,7 @@
__mul__ = interp2app(BaseArray.descr_mul),
__div__ = interp2app(BaseArray.descr_div),
__truediv__ = interp2app(BaseArray.descr_truediv),
+ __floordiv__ = interp2app(BaseArray.descr_floordiv),
__mod__ = interp2app(BaseArray.descr_mod),
__divmod__ = interp2app(BaseArray.descr_divmod),
__pow__ = interp2app(BaseArray.descr_pow),
@@ -1264,6 +1267,7 @@
__rmul__ = interp2app(BaseArray.descr_rmul),
__rdiv__ = interp2app(BaseArray.descr_rdiv),
__rtruediv__ = interp2app(BaseArray.descr_rtruediv),
+ __rfloordiv__ = interp2app(BaseArray.descr_rfloordiv),
__rmod__ = interp2app(BaseArray.descr_rmod),
__rdivmod__ = interp2app(BaseArray.descr_rdivmod),
__rpow__ = interp2app(BaseArray.descr_rpow),
diff --git a/pypy/module/micronumpy/interp_ufuncs.py
b/pypy/module/micronumpy/interp_ufuncs.py
--- a/pypy/module/micronumpy/interp_ufuncs.py
+++ b/pypy/module/micronumpy/interp_ufuncs.py
@@ -388,6 +388,7 @@
"int_only": True}),
("bitwise_xor", "bitwise_xor", 2, {"int_only": True}),
("invert", "invert", 1, {"int_only": True}),
+ ("floor_divide", "floordiv", 2, {"promote_bools": True}),
("divide", "div", 2, {"promote_bools": True}),
("true_divide", "div", 2, {"promote_to_float": True}),
("mod", "mod", 2, {"promote_bools": True}),
@@ -441,6 +442,14 @@
("arcsinh", "arcsinh", 1, {"promote_to_float": True}),
("arccosh", "arccosh", 1, {"promote_to_float": True}),
("arctanh", "arctanh", 1, {"promote_to_float": True}),
+
+ ("radians", "radians", 1, {"promote_to_float": True}),
+ ("degrees", "degrees", 1, {"promote_to_float": True}),
+
+ ("log", "log", 1, {"promote_to_float": True}),
+ ("log2", "log2", 1, {"promote_to_float": True}),
+ ("log10", "log10", 1, {"promote_to_float": True}),
+ ("log1p", "log1p", 1, {"promote_to_float": True}),
]:
self.add_ufunc(space, *ufunc_def)
diff --git a/pypy/module/micronumpy/test/test_numarray.py
b/pypy/module/micronumpy/test/test_numarray.py
--- a/pypy/module/micronumpy/test/test_numarray.py
+++ b/pypy/module/micronumpy/test/test_numarray.py
@@ -625,6 +625,56 @@
for i in range(5):
assert b[i] == i / 5.0
+ def test_floordiv(self):
+ from math import isnan
+ from _numpypy import array, dtype
+
+ a = array(range(1, 6))
+ b = a // a
+ assert (b == [1, 1, 1, 1, 1]).all()
+
+ a = array(range(1, 6), dtype=bool)
+ b = a // a
+ assert b.dtype is dtype("int8")
+ assert (b == [1, 1, 1, 1, 1]).all()
+
+ a = array([-1, 0, 1])
+ b = array([0, 0, 0])
+ c = a // b
+ assert (c == [0, 0, 0]).all()
+
+ a = array([-1.0, 0.0, 1.0])
+ b = array([0.0, 0.0, 0.0])
+ c = a // b
+ assert c[0] == float('-inf')
+ assert isnan(c[1])
+ assert c[2] == float('inf')
+
+ b = array([-0.0, -0.0, -0.0])
+ c = a // b
+ assert c[0] == float('inf')
+ assert isnan(c[1])
+ assert c[2] == float('-inf')
+
+ def test_floordiv_other(self):
+ from _numpypy import array
+ a = array(range(5))
+ b = array([2, 2, 2, 2, 2], float)
+ c = a // b
+ assert (c == [0, 0, 1, 1, 2]).all()
+
+ def test_rfloordiv(self):
+ from _numpypy import array
+ a = array(range(1, 6))
+ b = 3 // a
+ assert (b == [3, 1, 1, 0, 0]).all()
+
+ def test_floordiv_constant(self):
+ from _numpypy import array
+ a = array(range(5))
+ b = a // 2
+ assert (b == [0, 0, 1, 1, 2]).all()
+
def test_truediv(self):
from operator import truediv
from _numpypy import arange
diff --git a/pypy/module/micronumpy/test/test_ufuncs.py
b/pypy/module/micronumpy/test/test_ufuncs.py
--- a/pypy/module/micronumpy/test/test_ufuncs.py
+++ b/pypy/module/micronumpy/test/test_ufuncs.py
@@ -376,6 +376,45 @@
assert math.isnan(sqrt(-1))
assert math.isnan(sqrt(nan))
+ def test_radians(self):
+ import math
+ from _numpypy import radians, array
+ a = array([
+ -181, -180, -179,
+ 181, 180, 179,
+ 359, 360, 361,
+ 400, -1, 0, 1,
+ float('inf'), float('-inf')])
+ b = radians(a)
+ for i in range(len(a)):
+ assert b[i] == math.radians(a[i])
+
+ def test_deg2rad(self):
+ import math
+ from _numpypy import deg2rad, array
+ a = array([
+ -181, -180, -179,
+ 181, 180, 179,
+ 359, 360, 361,
+ 400, -1, 0, 1,
+ float('inf'), float('-inf')])
+ b = deg2rad(a)
+ for i in range(len(a)):
+ assert b[i] == math.radians(a[i])
+
+ def test_degrees(self):
+ import math
+ from _numpypy import degrees, array
+ a = array([
+ -181, -180, -179,
+ 181, 180, 179,
+ 359, 360, 361,
+ 400, -1, 0, 1,
+ float('inf'), float('-inf')])
+ b = degrees(a)
+ for i in range(len(a)):
+ assert b[i] == math.degrees(a[i])
+
def test_reduce_errors(self):
from _numpypy import sin, add
@@ -481,3 +520,47 @@
assert (logical_xor([True, False, True, False], [1, 2, 0, 0])
== [False, True, True, False]).all()
assert (logical_not([True, False]) == [False, True]).all()
+
+ def test_logn(self):
+ import math
+ from _numpypy import log, log2, log10
+
+ for log_func, base in [(log, math.e), (log2, 2), (log10, 10)]:
+ for v in [float('-nan'), float('-inf'), -1, float('nan')]:
+ assert math.isnan(log_func(v))
+ for v in [-0.0, 0.0]:
+ assert log_func(v) == float("-inf")
+ assert log_func(float('inf')) == float('inf')
+ assert (log_func([1, base]) == [0, 1]).all()
+
+ def test_log1p(self):
+ import math
+ from _numpypy import log1p
+
+ for v in [float('-nan'), float('-inf'), -2, float('nan')]:
+ assert math.isnan(log1p(v))
+ for v in [-1]:
+ assert log1p(v) == float("-inf")
+ assert log1p(float('inf')) == float('inf')
+ assert (log1p([0, 1e-50, math.e - 1]) == [0, 1e-50, 1]).all()
+
+ def test_power(self):
+ import math
+ from _numpypy import power, array
+ a = array([1., 2., 3.])
+ b = power(a, 3)
+ for i in range(len(a)):
+ assert b[i] == a[i] ** 3
+
+ a = array([1., 2., 3.])
+ b = array([1., 2., 3.])
+ c = power(a, b)
+ for i in range(len(a)):
+ assert c[i] == a[i] ** b[i]
+
+ def test_floordiv(self):
+ from _numpypy import floor_divide, array
+ a = array([1., 2., 3., 4., 5., 6., 6.01])
+ b = floor_divide(a, 2.5)
+ for i in range(len(a)):
+ assert b[i] == a[i] // 2.5
diff --git a/pypy/module/micronumpy/types.py b/pypy/module/micronumpy/types.py
--- a/pypy/module/micronumpy/types.py
+++ b/pypy/module/micronumpy/types.py
@@ -10,6 +10,8 @@
from pypy.rpython.lltypesystem import lltype, rffi
from pypy.rlib.rstruct.runpack import runpack
+degToRad = math.pi / 180.0
+log2 = math.log(2)
def simple_unary_op(func):
specialize.argtype(1)(func)
@@ -280,6 +282,12 @@
return v1 / v2
@simple_binary_op
+ def floordiv(self, v1, v2):
+ if v2 == 0:
+ return 0
+ return v1 // v2
+
+ @simple_binary_op
def mod(self, v1, v2):
return v1 % v2
@@ -418,6 +426,15 @@
return rfloat.copysign(rfloat.INFINITY, v1 * v2)
@simple_binary_op
+ def floordiv(self, v1, v2):
+ try:
+ return math.floor(v1 / v2)
+ except ZeroDivisionError:
+ if v1 == v2 == 0.0:
+ return rfloat.NAN
+ return rfloat.copysign(rfloat.INFINITY, v1 * v2)
+
+ @simple_binary_op
def mod(self, v1, v2):
return math.fmod(v1, v2)
@@ -533,6 +550,57 @@
def isinf(self, v):
return rfloat.isinf(v)
+ @simple_unary_op
+ def radians(self, v):
+ return v * degToRad
+ deg2rad = radians
+
+ @simple_unary_op
+ def degrees(self, v):
+ return v / degToRad
+
+ @simple_unary_op
+ def log(self, v):
+ try:
+ return math.log(v)
+ except ValueError:
+ if v == 0.0:
+ # CPython raises ValueError here, so we have to check
+ # the value to find the correct numpy return value
+ return -rfloat.INFINITY
+ return rfloat.NAN
+
+ @simple_unary_op
+ def log2(self, v):
+ try:
+ return math.log(v) / log2
+ except ValueError:
+ if v == 0.0:
+ # CPython raises ValueError here, so we have to check
+ # the value to find the correct numpy return value
+ return -rfloat.INFINITY
+ return rfloat.NAN
+
+ @simple_unary_op
+ def log10(self, v):
+ try:
+ return math.log10(v)
+ except ValueError:
+ if v == 0.0:
+ # CPython raises ValueError here, so we have to check
+ # the value to find the correct numpy return value
+ return -rfloat.INFINITY
+ return rfloat.NAN
+
+ @simple_unary_op
+ def log1p(self, v):
+ try:
+ return rfloat.log1p(v)
+ except OverflowError:
+ return -rfloat.INFINITY
+ except ValueError:
+ return rfloat.NAN
+
class Float32(BaseType, Float):
T = rffi.FLOAT
diff --git a/pypy/objspace/std/stringobject.py
b/pypy/objspace/std/stringobject.py
--- a/pypy/objspace/std/stringobject.py
+++ b/pypy/objspace/std/stringobject.py
@@ -56,9 +56,18 @@
return w_self._value
def unicode_w(w_self, space):
- # XXX should this use the default encoding?
- from pypy.objspace.std.unicodetype import plain_str2unicode
- return plain_str2unicode(space, w_self._value)
+ # Use the default encoding.
+ from pypy.objspace.std.unicodetype import unicode_from_string, \
+ decode_object
+ w_defaultencoding = space.call_function(space.sys.get(
+ 'getdefaultencoding'))
+ from pypy.objspace.std.unicodetype import _get_encoding_and_errors, \
+ unicode_from_string, decode_object
+ encoding, errors = _get_encoding_and_errors(space, w_defaultencoding,
+ space.w_None)
+ if encoding is None and errors is None:
+ return space.unicode_w(unicode_from_string(space, w_self))
+ return space.unicode_w(decode_object(space, w_self, encoding, errors))
registerimplementation(W_StringObject)
diff --git a/pypy/objspace/std/test/test_stringobject.py
b/pypy/objspace/std/test/test_stringobject.py
--- a/pypy/objspace/std/test/test_stringobject.py
+++ b/pypy/objspace/std/test/test_stringobject.py
@@ -501,6 +501,35 @@
raises(TypeError, ''.join, [1])
raises(TypeError, ''.join, [[1]])
+ def test_unicode_join_str_arg_ascii(self):
+ raises(UnicodeDecodeError, u''.join, ['\xc3\xa1'])
+
+ def test_unicode_join_str_arg_utf8(self):
+ # Need default encoding utf-8, but sys.setdefaultencoding
+ # is removed after startup.
+ import sys
+ old_encoding = sys.getdefaultencoding()
+ # Duplicate unittest.test_support.CleanImport logic because it won't
+ # import.
+ self.original_modules = sys.modules.copy()
+ try:
+ import sys as temp_sys
+ module_name = 'sys'
+ if module_name in sys.modules:
+ module = sys.modules[module_name]
+ # It is possible that module_name is just an alias for
+ # another module (e.g. stub for modules renamed in 3.x).
+ # In that case, we also need delete the real module to
+ # clear the import cache.
+ if module.__name__ != module_name:
+ del sys.modules[module.__name__]
+ del sys.modules[module_name]
+ temp_sys.setdefaultencoding('utf-8')
+ assert u''.join(['\xc3\xa1']) == u'\xe1'
+ finally:
+ temp_sys.setdefaultencoding(old_encoding)
+ sys.modules.update(self.original_modules)
+
def test_unicode_join_endcase(self):
# This class inserts a Unicode object into its argument's natural
# iteration, in the 3rd position.
diff --git a/pypy/objspace/std/tupleobject.py b/pypy/objspace/std/tupleobject.py
--- a/pypy/objspace/std/tupleobject.py
+++ b/pypy/objspace/std/tupleobject.py
@@ -8,7 +8,10 @@
from pypy.objspace.std.slicetype import unwrap_start_stop
from pypy.objspace.std import slicetype
from pypy.interpreter import gateway
+from pypy.rlib import jit
+# Tuples of known length up to UNROLL_TUPLE_LIMIT have unrolled certain methods
+UNROLL_TUPLE_LIMIT = 10
class W_AbstractTupleObject(W_Object):
__slots__ = ()
@@ -103,6 +106,13 @@
def mul__ANY_Tuple(space, w_times, w_tuple):
return mul__Tuple_ANY(space, w_tuple, w_times)
+def tuple_unroll_condition(space, w_tuple1, w_tuple2):
+ lgt1 = w_tuple1.length()
+ lgt2 = w_tuple2.length()
+ return ((jit.isconstant(lgt1) and lgt1 <= UNROLL_TUPLE_LIMIT) or
+ (jit.isconstant(lgt2) and lgt2 <= UNROLL_TUPLE_LIMIT))
+
[email protected]_inside_iff(tuple_unroll_condition)
def eq__Tuple_Tuple(space, w_tuple1, w_tuple2):
if w_tuple1.tuplestorage.getshape() is not
w_tuple2.tuplestorage.getshape():
return space.w_False
@@ -113,6 +123,7 @@
return space.w_False
return space.w_True
[email protected]_inside_iff(tuple_unroll_condition)
def lt__Tuple_Tuple(space, w_tuple1, w_tuple2):
ncmp = min(w_tuple1.length(), w_tuple2.length())
# Search for the first index where items are different
@@ -124,6 +135,7 @@
# No more items to compare -- compare sizes
return space.newbool(w_tuple1.length() < w_tuple2.length())
[email protected]_inside_iff(tuple_unroll_condition)
def gt__Tuple_Tuple(space, w_tuple1, w_tuple2):
ncmp = min(w_tuple1.length(), w_tuple2.length())
# Search for the first index where items are different
@@ -145,7 +157,13 @@
repr += ")"
return space.wrap(repr)
-def hash_items(space, w_tuple):
+def hash__Tuple(space, w_tuple):
+ return space.wrap(hash_tuple(space, w_tuple.wrappeditems))
+
[email protected]_inside_iff(lambda space, w_tuple:
+ jit.isconstant(w_tuple.length()) and
+ w_tuple.length() < UNROLL_TUPLE_LIMIT)
+def hash_tuple(space, w_tuple):
# this is the CPython 2.4 algorithm (changed from 2.3)
mult = 1000003
x = 0x345678
@@ -158,12 +176,6 @@
x += 97531
return intmask(x)
-def hash__Tuple(space, w_tuple):
- return space.wrap(hash_items(space, w_tuple))
-
-def hash_tuple(space, wrappeditems):
- pass
-
def getnewargs__Tuple(space, w_tuple):
return space.newtuple([space.newtuple(w_tuple.tolist(space))])
diff --git a/pypy/rlib/rfloat.py b/pypy/rlib/rfloat.py
--- a/pypy/rlib/rfloat.py
+++ b/pypy/rlib/rfloat.py
@@ -375,8 +375,7 @@
def log1p(x):
"NOT_RPYTHON"
- from pypy.rlib import rfloat
- if abs(x) < rfloat.DBL_EPSILON // 2.:
+ if abs(x) < DBL_EPSILON // 2.:
return x
elif -.5 <= x <= 1.:
y = 1. + x
_______________________________________________
pypy-commit mailing list
[email protected]
http://mail.python.org/mailman/listinfo/pypy-commit
