Author: Philip Jenvey <pjen...@underboss.org>
Branch: py3k
Changeset: r68477:d37bd06f36fa
Date: 2013-12-18 15:47 -0800
http://bitbucket.org/pypy/pypy/changeset/d37bd06f36fa/
Log: merge default
diff --git a/lib_pypy/_sha1.py b/lib_pypy/_sha1.py
--- a/lib_pypy/_sha1.py
+++ b/lib_pypy/_sha1.py
@@ -115,14 +115,14 @@
]
class sha:
- "An implementation of the MD5 hash function in pure Python."
+ "An implementation of the SHA hash function in pure Python."
digest_size = digestsize = 20
- block_size = 1
+ block_size = 512 // 8
def __init__(self):
"Initialisation."
-
+
# Initial message length in bits(!).
self.length = 0
self.count = [0, 0]
@@ -209,7 +209,7 @@
self.H2 = (self.H2 + C) & 0xffffffff
self.H3 = (self.H3 + D) & 0xffffffff
self.H4 = (self.H4 + E) & 0xffffffff
-
+
# Down from here all methods follow the Python Standard Library
# API of the sha module.
@@ -298,13 +298,13 @@
_long2bytesBigEndian(self.H3, 4) + \
_long2bytesBigEndian(self.H4, 4)
- self.H0 = H0
- self.H1 = H1
+ self.H0 = H0
+ self.H1 = H1
self.H2 = H2
self.H3 = H3
self.H4 = H4
- self.input = input
- self.count = count
+ self.input = input
+ self.count = count
return digest
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
@@ -10,7 +10,7 @@
'array': 'interp_numarray.array',
'zeros': 'interp_numarray.zeros',
'empty': 'interp_numarray.zeros',
- 'ones': 'interp_numarray.ones',
+ 'empty_like': 'interp_numarray.empty_like',
'_reconstruct' : 'interp_numarray._reconstruct',
'scalar' : 'interp_numarray.build_scalar',
'dot': 'interp_arrayops.dot',
@@ -106,8 +106,6 @@
('logaddexp2', 'logaddexp2'),
('real', 'real'),
('imag', 'imag'),
- ('ones_like', 'ones_like'),
- ('zeros_like', 'zeros_like'),
]:
interpleveldefs[exposed] = "interp_ufuncs.get(space).%s" % impl
diff --git a/pypy/module/micronumpy/arrayimpl/concrete.py
b/pypy/module/micronumpy/arrayimpl/concrete.py
--- a/pypy/module/micronumpy/arrayimpl/concrete.py
+++ b/pypy/module/micronumpy/arrayimpl/concrete.py
@@ -47,7 +47,7 @@
def setslice(self, space, arr):
impl = arr.implementation
if impl.is_scalar():
- self.fill(impl.get_scalar_value())
+ self.fill(space, impl.get_scalar_value())
return
shape = shape_agreement(space, self.get_shape(), arr)
if impl.storage == self.storage:
@@ -100,7 +100,7 @@
tmp = self.get_real(orig_array)
tmp.setslice(space, convert_to_array(space, w_value))
- def get_imag(self, orig_array):
+ def get_imag(self, space, orig_array):
strides = self.get_strides()
backstrides = self.get_backstrides()
if self.dtype.is_complex_type():
@@ -110,11 +110,11 @@
impl = NonWritableArray(self.get_shape(), self.dtype, self.order,
strides,
backstrides)
if not self.dtype.is_flexible_type():
- impl.fill(self.dtype.box(0))
+ impl.fill(space, self.dtype.box(0))
return impl
def set_imag(self, space, orig_array, w_value):
- tmp = self.get_imag(orig_array)
+ tmp = self.get_imag(space, orig_array)
tmp.setslice(space, convert_to_array(space, w_value))
# -------------------- applevel get/setitem -----------------------
@@ -357,7 +357,7 @@
self.get_backstrides(),
self.get_shape())
- def fill(self, box):
+ def fill(self, space, box):
self.dtype.itemtype.fill(self.storage, self.dtype.get_size(),
box, 0, self.size, 0)
@@ -435,8 +435,8 @@
def base(self):
return self.orig_arr
- def fill(self, box):
- loop.fill(self, box.convert_to(self.dtype))
+ def fill(self, space, box):
+ loop.fill(self, box.convert_to(space, self.dtype))
def create_iter(self, shape=None, backward_broadcast=False,
require_index=False):
if shape is not None and \
diff --git a/pypy/module/micronumpy/arrayimpl/scalar.py
b/pypy/module/micronumpy/arrayimpl/scalar.py
--- a/pypy/module/micronumpy/arrayimpl/scalar.py
+++ b/pypy/module/micronumpy/arrayimpl/scalar.py
@@ -54,8 +54,7 @@
return self.value
def set_scalar_value(self, w_val):
- assert isinstance(w_val, W_GenericBox)
- self.value = w_val.convert_to(self.dtype)
+ self.value = w_val
def copy(self, space):
scalar = Scalar(self.dtype)
@@ -96,12 +95,12 @@
','.join([str(x) for x in w_arr.get_shape()],))))
if self.dtype.is_complex_type():
self.value = self.dtype.itemtype.composite(
- w_arr.get_scalar_value().convert_to(dtype),
+ w_arr.get_scalar_value().convert_to(space,
dtype),
self.value.convert_imag_to(dtype))
else:
self.value = w_arr.get_scalar_value()
- def get_imag(self, orig_array):
+ def get_imag(self, space, orig_array):
if self.dtype.is_complex_type():
scalar = Scalar(self.dtype.float_type)
scalar.value = self.value.convert_imag_to(scalar.dtype)
@@ -125,7 +124,7 @@
','.join([str(x) for x in w_arr.get_shape()],))))
self.value = self.dtype.itemtype.composite(
self.value.convert_real_to(dtype),
- w_arr.get_scalar_value().convert_to(dtype),
+ w_arr.get_scalar_value().convert_to(space, dtype),
)
def descr_getitem(self, space, _, w_idx):
@@ -180,7 +179,7 @@
w_res.implementation.setitem(0, index_type.itemtype.box(0))
return space.newtuple([w_res])
- def fill(self, w_value):
+ def fill(self, space, w_value):
self.value = w_value
def get_storage_as_int(self, space):
diff --git a/pypy/module/micronumpy/interp_arrayops.py
b/pypy/module/micronumpy/interp_arrayops.py
--- a/pypy/module/micronumpy/interp_arrayops.py
+++ b/pypy/module/micronumpy/interp_arrayops.py
@@ -89,7 +89,7 @@
shape = shape_agreement(space, arr.get_shape(), x)
shape = shape_agreement(space, shape, y)
out = W_NDimArray.from_shape(space, shape, dtype)
- return loop.where(out, shape, arr, x, y, dtype)
+ return loop.where(space, out, shape, arr, x, y, dtype)
def dot(space, w_obj1, w_obj2, w_out=None):
w_arr = convert_to_array(space, w_obj1)
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
@@ -66,7 +66,7 @@
def __init__(self, value):
self.value = value
- def convert_to(self, dtype):
+ def convert_to(self, space, dtype):
return dtype.box(self.value)
def __repr__(self):
@@ -91,7 +91,7 @@
self.real = real
self.imag = imag
- def convert_to(self, dtype):
+ def convert_to(self, space, dtype):
return dtype.box_complex(self.real, self.imag)
def convert_real_to(self, dtype):
@@ -149,12 +149,12 @@
return space.index(self.item(space))
def descr_int(self, space):
- box = self.convert_to(W_LongBox._get_dtype(space))
+ box = self.convert_to(space, W_LongBox._get_dtype(space))
assert isinstance(box, W_LongBox)
return space.wrap(box.value)
def descr_float(self, space):
- box = self.convert_to(W_Float64Box._get_dtype(space))
+ box = self.convert_to(space, W_Float64Box._get_dtype(space))
assert isinstance(box, W_Float64Box)
return space.wrap(box.value)
@@ -260,14 +260,13 @@
if not space.is_none(w_out):
raise OperationError(space.w_NotImplementedError, space.wrap(
"out not supported"))
- v = self.convert_to(self.get_dtype(space))
- return self.get_dtype(space).itemtype.round(v, decimals)
+ return self.get_dtype(space).itemtype.round(self, decimals)
def descr_astype(self, space, w_dtype):
from pypy.module.micronumpy.interp_dtype import W_Dtype
dtype = space.interp_w(W_Dtype,
space.call_function(space.gettypefor(W_Dtype), w_dtype))
- return self.convert_to(dtype)
+ return self.convert_to(space, dtype)
def descr_view(self, space, w_dtype):
from pypy.module.micronumpy.interp_dtype import W_Dtype
@@ -306,7 +305,10 @@
return space.wrap(0)
def descr_copy(self, space):
- return self.convert_to(self.get_dtype(space))
+ return self.convert_to(space, self.get_dtype(space))
+
+ def descr_buffer(self, space):
+ return self.descr_ravel(space).descr_get_data(space)
w_flags = None
def descr_get_flags(self, space):
@@ -468,14 +470,16 @@
dtype.itemtype.store(self.arr, self.ofs, ofs,
dtype.coerce(space, w_value))
- def convert_to(self, dtype):
+ def convert_to(self, space, dtype):
# if we reach here, the record fields are guarenteed to match.
return self
class W_CharacterBox(W_FlexibleBox):
- def convert_to(self, dtype):
- # XXX assert dtype is str type
- return self
+ def convert_to(self, space, dtype):
+ return dtype.coerce(space, space.wrap(self.raw_str()))
+
+ def descr_len(self, space):
+ return space.len(self.item(space))
class W_StringBox(W_CharacterBox):
def descr__new__string_box(space, w_subtype, w_arg):
@@ -514,6 +518,7 @@
__bool__ = interp2app(W_GenericBox.descr_nonzero),
__oct__ = interp2app(W_GenericBox.descr_oct),
__hex__ = interp2app(W_GenericBox.descr_hex),
+ __buffer__ = interp2app(W_GenericBox.descr_buffer),
__add__ = interp2app(W_GenericBox.descr_add),
__sub__ = interp2app(W_GenericBox.descr_sub),
@@ -748,9 +753,11 @@
W_StringBox.typedef = TypeDef("bytes_", (W_CharacterBox.typedef, str_typedef),
__module__ = "numpy",
__new__ = interp2app(W_StringBox.descr__new__string_box.im_func),
+ __len__ = interp2app(W_StringBox.descr_len),
)
W_UnicodeBox.typedef = TypeDef("str_", (W_CharacterBox.typedef,
unicode_typedef),
__module__ = "numpy",
__new__ = interp2app(W_UnicodeBox.descr__new__unicode_box.im_func),
+ __len__ = interp2app(W_UnicodeBox.descr_len),
)
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
@@ -94,7 +94,7 @@
return space.wrap(self.get_size() * self.get_dtype().get_size())
def descr_fill(self, space, w_value):
- self.fill(self.get_dtype().coerce(space, w_value))
+ self.fill(space, self.get_dtype().coerce(space, w_value))
def descr_tostring(self, space, w_order=None):
order = order_converter(space, w_order, NPY_CORDER)
@@ -288,8 +288,8 @@
def set_scalar_value(self, w_val):
self.implementation.set_scalar_value(w_val)
- def fill(self, box):
- self.implementation.fill(box)
+ def fill(self, space, box):
+ self.implementation.fill(space, box)
def descr_get_size(self, space):
return space.wrap(self.get_size())
@@ -314,7 +314,7 @@
self.implementation.get_real(self))
def descr_get_imag(self, space):
- ret = self.implementation.get_imag(self)
+ ret = self.implementation.get_imag(space, self)
return wrap_impl(space, space.type(self), self, ret)
def descr_set_real(self, space, w_value):
@@ -539,7 +539,7 @@
def descr_astype(self, space, w_dtype):
dtype = space.interp_w(interp_dtype.W_Dtype,
- space.call_function(space.gettypefor(interp_dtype.W_Dtype), w_dtype))
+ space.call_function(space.gettypefor(interp_dtype.W_Dtype),
w_dtype))
impl = self.implementation
if isinstance(impl, scalar.Scalar):
return W_NDimArray.new_scalar(space, dtype, impl.value)
@@ -956,8 +956,7 @@
return func_with_new_name(impl, "reduce_%s_impl_%d_%d" % (ufunc_name,
promote_to_largest, cumulative))
- descr_sum = _reduce_ufunc_impl("add")
- descr_sum_promote = _reduce_ufunc_impl("add", True)
+ descr_sum = _reduce_ufunc_impl("add", True)
descr_prod = _reduce_ufunc_impl("multiply", True)
descr_max = _reduce_ufunc_impl("maximum")
descr_min = _reduce_ufunc_impl("minimum")
@@ -988,19 +987,49 @@
shape = self.get_shape()
if len(shape) == 0:
assert isinstance(self.implementation, scalar.Scalar)
- return
space.int(space.wrap(self.implementation.get_scalar_value()))
- if shape == [1]:
- return space.int(self.descr_getitem(space, space.wrap(0)))
- raise OperationError(space.w_TypeError, space.wrap("only length-1
arrays can be converted to Python scalars"))
+ value = space.wrap(self.implementation.get_scalar_value())
+ elif shape == [1]:
+ value = self.descr_getitem(space, space.wrap(0))
+ else:
+ raise OperationError(space.w_TypeError, space.wrap(
+ "only length-1 arrays can be converted to Python scalars"))
+ if self.get_dtype().is_str_or_unicode():
+ raise OperationError(space.w_TypeError, space.wrap(
+ "don't know how to convert scalar number to int"))
+ return space.int(value)
def descr_float(self, space):
shape = self.get_shape()
if len(shape) == 0:
assert isinstance(self.implementation, scalar.Scalar)
- return
space.float(space.wrap(self.implementation.get_scalar_value()))
- if shape == [1]:
- return space.float(self.descr_getitem(space, space.wrap(0)))
- raise OperationError(space.w_TypeError, space.wrap("only length-1
arrays can be converted to Python scalars"))
+ value = space.wrap(self.implementation.get_scalar_value())
+ elif shape == [1]:
+ value = self.descr_getitem(space, space.wrap(0))
+ else:
+ raise OperationError(space.w_TypeError, space.wrap(
+ "only length-1 arrays can be converted to Python scalars"))
+ if self.get_dtype().is_str_or_unicode():
+ raise OperationError(space.w_TypeError, space.wrap(
+ "don't know how to convert scalar number to float"))
+ return space.float(value)
+
+ def descr_index(self, space):
+ shape = self.get_shape()
+ if len(shape) == 0:
+ assert isinstance(self.implementation, scalar.Scalar)
+ value = space.wrap(self.implementation.get_scalar_value())
+ elif shape == [1]:
+ value = self.descr_getitem(space, space.wrap(0))
+ else:
+ raise OperationError(space.w_TypeError, space.wrap(
+ "only integer arrays with one element "
+ "can be converted to an index"))
+ if not self.get_dtype().is_int_type() or
self.get_dtype().is_bool_type():
+ raise OperationError(space.w_TypeError, space.wrap(
+ "only integer arrays with one element "
+ "can be converted to an index"))
+ assert isinstance(value, interp_boxes.W_GenericBox)
+ return value.item(space)
def descr_reduce(self, space):
from rpython.rlib.rstring import StringBuilder
@@ -1101,8 +1130,6 @@
w_base=w_buffer,
writable=buf.is_writable())
- if not shape:
- return W_NDimArray.new_scalar(space, dtype)
order = order_converter(space, w_order, NPY_CORDER)
if order == NPY_CORDER:
order = 'C'
@@ -1179,6 +1206,7 @@
__int__ = interp2app(W_NDimArray.descr_int),
__float__ = interp2app(W_NDimArray.descr_float),
__buffer__ = interp2app(W_NDimArray.descr_get_data),
+ __index__ = interp2app(W_NDimArray.descr_index),
__pos__ = interp2app(W_NDimArray.descr_pos),
__neg__ = interp2app(W_NDimArray.descr_neg),
@@ -1358,36 +1386,34 @@
# arrays with correct dtype
dtype = interp_dtype.decode_w_dtype(space, w_dtype)
if isinstance(w_object, W_NDimArray) and \
- (space.is_none(w_dtype) or w_object.get_dtype() is dtype):
+ (space.is_none(w_dtype) or w_object.get_dtype() is dtype):
shape = w_object.get_shape()
if copy:
w_ret = w_object.descr_copy(space)
else:
- if ndmin<= len(shape):
+ if ndmin <= len(shape):
return w_object
new_impl = w_object.implementation.set_shape(space, w_object,
shape)
w_ret = W_NDimArray(new_impl)
if ndmin > len(shape):
shape = [1] * (ndmin - len(shape)) + shape
w_ret.implementation = w_ret.implementation.set_shape(space,
- w_ret, shape)
+ w_ret, shape)
return w_ret
# not an array or incorrect dtype
shape, elems_w = find_shape_and_elems(space, w_object, dtype)
- if dtype is None or (
- dtype.is_str_or_unicode() and dtype.get_size() < 1):
+ if dtype is None or (dtype.is_str_or_unicode() and dtype.get_size() < 1):
for w_elem in elems_w:
- dtype = interp_ufuncs.find_dtype_for_scalar(space, w_elem,
- dtype)
- #if dtype is interp_dtype.get_dtype_cache(space).w_float64dtype:
- # break
-
+ if isinstance(w_elem, W_NDimArray) and w_elem.is_scalar():
+ w_elem = w_elem.get_scalar_value()
+ dtype = interp_ufuncs.find_dtype_for_scalar(space, w_elem, dtype)
if dtype is None:
dtype = interp_dtype.get_dtype_cache(space).w_float64dtype
- if dtype.is_str_or_unicode() and dtype.get_size() < 1:
- # promote S0 -> S1, U0 -> U1
- dtype = interp_dtype.variable_dtype(space, dtype.char + '1')
+ elif dtype.is_str_or_unicode() and dtype.get_size() < 1:
+ # promote S0 -> S1, U0 -> U1
+ dtype = interp_dtype.variable_dtype(space, dtype.char + '1')
+
if ndmin > len(shape):
shape = [1] * (ndmin - len(shape)) + shape
w_arr = W_NDimArray.from_shape(space, shape, dtype, order=order)
@@ -1400,25 +1426,20 @@
@unwrap_spec(order=str)
def zeros(space, w_shape, w_dtype=None, order='C'):
dtype = space.interp_w(interp_dtype.W_Dtype,
- space.call_function(space.gettypefor(interp_dtype.W_Dtype), w_dtype)
- )
+ space.call_function(space.gettypefor(interp_dtype.W_Dtype), w_dtype))
shape = _find_shape(space, w_shape, dtype)
- if not shape:
- return W_NDimArray.new_scalar(space, dtype, space.wrap(0))
- return space.wrap(W_NDimArray.from_shape(space, shape, dtype=dtype,
order=order))
+ return W_NDimArray.from_shape(space, shape, dtype=dtype, order=order)
-@unwrap_spec(order=str)
-def ones(space, w_shape, w_dtype=None, order='C'):
- dtype = space.interp_w(interp_dtype.W_Dtype,
- space.call_function(space.gettypefor(interp_dtype.W_Dtype), w_dtype)
- )
- shape = _find_shape(space, w_shape, dtype)
- if not shape:
- return W_NDimArray.new_scalar(space, dtype, space.wrap(0))
- w_arr = W_NDimArray.from_shape(space, shape, dtype=dtype, order=order)
- one = dtype.box(1)
- w_arr.fill(one)
- return space.wrap(w_arr)
+@unwrap_spec(subok=bool)
+def empty_like(space, w_a, w_dtype=None, w_order=None, subok=True):
+ w_a = convert_to_array(space, w_a)
+ if w_dtype is None:
+ dtype = w_a.get_dtype()
+ else:
+ dtype = space.interp_w(interp_dtype.W_Dtype,
+ space.call_function(space.gettypefor(interp_dtype.W_Dtype),
w_dtype))
+ return W_NDimArray.from_shape(space, w_a.get_shape(), dtype=dtype,
+ w_instance=w_a if subok else None)
def _reconstruct(space, w_subtype, w_shape, w_dtype):
return descr_new_array(space, w_subtype, w_shape, w_dtype)
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
@@ -226,7 +226,7 @@
dtype = out.get_dtype()
else:
out = W_NDimArray.from_shape(space, shape, dtype,
w_instance=obj)
- return loop.do_axis_reduce(shape, self.func, obj, dtype, axis, out,
+ return loop.do_axis_reduce(space, shape, self.func, obj, dtype,
axis, out,
self.identity, cumulative, temp)
if cumulative:
if out:
@@ -235,7 +235,7 @@
"out of incompatible size"))
else:
out = W_NDimArray.from_shape(space, [obj.get_size()], dtype,
w_instance=obj)
- loop.compute_reduce_cumulative(obj, out, dtype, self.func,
+ loop.compute_reduce_cumulative(space, obj, out, dtype, self.func,
self.identity)
return out
if out:
@@ -244,7 +244,7 @@
"for reduction operation %s has too many"
" dimensions",self.name)
dtype = out.get_dtype()
- res = loop.compute_reduce(obj, dtype, self.func, self.done_func,
+ res = loop.compute_reduce(space, obj, dtype, self.func, self.done_func,
self.identity)
if out:
out.set_scalar_value(res)
@@ -303,13 +303,13 @@
res_dtype =
interp_dtype.get_dtype_cache(space).w_float64dtype
if w_obj.is_scalar():
w_val = self.func(calc_dtype,
- w_obj.get_scalar_value().convert_to(calc_dtype))
+ w_obj.get_scalar_value().convert_to(space,
calc_dtype))
if out is None:
return w_val
if out.is_scalar():
out.set_scalar_value(w_val)
else:
- out.fill(res_dtype.coerce(space, w_val))
+ out.fill(space, res_dtype.coerce(space, w_val))
return out
shape = shape_agreement(space, w_obj.get_shape(), out,
broadcast_down=False)
@@ -395,14 +395,14 @@
res_dtype = calc_dtype
if w_lhs.is_scalar() and w_rhs.is_scalar():
arr = self.func(calc_dtype,
- w_lhs.get_scalar_value().convert_to(calc_dtype),
- w_rhs.get_scalar_value().convert_to(calc_dtype)
+ w_lhs.get_scalar_value().convert_to(space, calc_dtype),
+ w_rhs.get_scalar_value().convert_to(space, calc_dtype)
)
if isinstance(out, W_NDimArray):
if out.is_scalar():
out.set_scalar_value(arr)
else:
- out.fill(arr)
+ out.fill(space, arr)
else:
out = arr
return out
@@ -496,6 +496,15 @@
@jit.unroll_safe
def find_unaryop_result_dtype(space, dt, promote_to_float=False,
promote_bools=False, promote_to_largest=False):
+ if promote_to_largest:
+ if dt.kind == NPY_GENBOOLLTR or dt.kind == NPY_SIGNEDLTR:
+ return interp_dtype.get_dtype_cache(space).w_int64dtype
+ elif dt.kind == NPY_UNSIGNEDLTR:
+ return interp_dtype.get_dtype_cache(space).w_uint64dtype
+ elif dt.kind == NPY_FLOATINGLTR or dt.kind == NPY_COMPLEXLTR:
+ return dt
+ else:
+ assert False
if promote_bools and (dt.kind == NPY_GENBOOLLTR):
return interp_dtype.get_dtype_cache(space).w_int8dtype
if promote_to_float:
@@ -507,15 +516,6 @@
if (dtype.kind == NPY_FLOATINGLTR and
dtype.itemtype.get_element_size() >
dt.itemtype.get_element_size()):
return dtype
- if promote_to_largest:
- if dt.kind == NPY_GENBOOLLTR or dt.kind == NPY_SIGNEDLTR:
- return interp_dtype.get_dtype_cache(space).w_float64dtype
- elif dt.kind == NPY_FLOATINGLTR:
- return interp_dtype.get_dtype_cache(space).w_float64dtype
- elif dt.kind == NPY_UNSIGNEDLTR:
- return interp_dtype.get_dtype_cache(space).w_uint64dtype
- else:
- assert False
return dt
def find_dtype_for_scalar(space, w_obj, current_guess=None):
@@ -685,9 +685,6 @@
"allow_complex": False}),
("logaddexp2", "logaddexp2", 2, {"promote_to_float": True,
"allow_complex": False}),
-
- ("ones_like", "ones_like", 1),
- ("zeros_like", "zeros_like", 1),
]:
self.add_ufunc(space, *ufunc_def)
diff --git a/pypy/module/micronumpy/loop.py b/pypy/module/micronumpy/loop.py
--- a/pypy/module/micronumpy/loop.py
+++ b/pypy/module/micronumpy/loop.py
@@ -58,10 +58,10 @@
out=out,
left_iter=left_iter,
right_iter=right_iter,
out_iter=out_iter)
- w_left = left_iter.getitem().convert_to(calc_dtype)
- w_right = right_iter.getitem().convert_to(calc_dtype)
+ w_left = left_iter.getitem().convert_to(space, calc_dtype)
+ w_right = right_iter.getitem().convert_to(space, calc_dtype)
out_iter.setitem(func(calc_dtype, w_left, w_right).convert_to(
- res_dtype))
+ space, res_dtype))
left_iter.next()
right_iter.next()
out_iter.next()
@@ -84,8 +84,8 @@
calc_dtype=calc_dtype,
res_dtype=res_dtype,
shape=shape, w_obj=w_obj, out=out,
obj_iter=obj_iter, out_iter=out_iter)
- elem = obj_iter.getitem().convert_to(calc_dtype)
- out_iter.setitem(func(calc_dtype, elem).convert_to(res_dtype))
+ elem = obj_iter.getitem().convert_to(space, calc_dtype)
+ out_iter.setitem(func(calc_dtype, elem).convert_to(space, res_dtype))
out_iter.next()
obj_iter.next()
return out
@@ -111,7 +111,7 @@
shapelen = len(shape)
while not target_iter.done():
setslice_driver1.jit_merge_point(shapelen=shapelen, dtype=dtype)
- target_iter.setitem(source_iter.getitem().convert_to(dtype))
+ target_iter.setitem(source_iter.getitem().convert_to(space, dtype))
target_iter.next()
source_iter.next()
return target
@@ -135,20 +135,20 @@
'calc_dtype'],
reds = 'auto')
-def compute_reduce(obj, calc_dtype, func, done_func, identity):
+def compute_reduce(space, obj, calc_dtype, func, done_func, identity):
obj_iter = obj.create_iter()
if identity is None:
- cur_value = obj_iter.getitem().convert_to(calc_dtype)
+ cur_value = obj_iter.getitem().convert_to(space, calc_dtype)
obj_iter.next()
else:
- cur_value = identity.convert_to(calc_dtype)
+ cur_value = identity.convert_to(space, calc_dtype)
shapelen = len(obj.get_shape())
while not obj_iter.done():
reduce_driver.jit_merge_point(shapelen=shapelen, func=func,
done_func=done_func,
calc_dtype=calc_dtype,
)
- rval = obj_iter.getitem().convert_to(calc_dtype)
+ rval = obj_iter.getitem().convert_to(space, calc_dtype)
if done_func is not None and done_func(calc_dtype, rval):
return rval
cur_value = func(calc_dtype, cur_value, rval)
@@ -159,22 +159,22 @@
greens = ['shapelen', 'func', 'dtype'],
reds = 'auto')
-def compute_reduce_cumulative(obj, out, calc_dtype, func, identity):
+def compute_reduce_cumulative(space, obj, out, calc_dtype, func, identity):
obj_iter = obj.create_iter()
out_iter = out.create_iter()
if identity is None:
- cur_value = obj_iter.getitem().convert_to(calc_dtype)
+ cur_value = obj_iter.getitem().convert_to(space, calc_dtype)
out_iter.setitem(cur_value)
out_iter.next()
obj_iter.next()
else:
- cur_value = identity.convert_to(calc_dtype)
+ cur_value = identity.convert_to(space, calc_dtype)
shapelen = len(obj.get_shape())
while not obj_iter.done():
reduce_cum_driver.jit_merge_point(shapelen=shapelen, func=func,
dtype=calc_dtype,
)
- rval = obj_iter.getitem().convert_to(calc_dtype)
+ rval = obj_iter.getitem().convert_to(space, calc_dtype)
cur_value = func(calc_dtype, cur_value, rval)
out_iter.setitem(cur_value)
out_iter.next()
@@ -190,7 +190,7 @@
greens = ['shapelen', 'dtype', 'arr_dtype'],
reds = 'auto')
-def where(out, shape, arr, x, y, dtype):
+def where(space, out, shape, arr, x, y, dtype):
out_iter = out.create_iter(shape)
arr_iter = arr.create_iter(shape)
arr_dtype = arr.get_dtype()
@@ -209,9 +209,9 @@
arr_dtype=arr_dtype)
w_cond = arr_iter.getitem()
if arr_dtype.itemtype.bool(w_cond):
- w_val = x_iter.getitem().convert_to(dtype)
+ w_val = x_iter.getitem().convert_to(space, dtype)
else:
- w_val = y_iter.getitem().convert_to(dtype)
+ w_val = y_iter.getitem().convert_to(space, dtype)
out_iter.setitem(w_val)
out_iter.next()
arr_iter.next()
@@ -224,7 +224,7 @@
'func', 'dtype'],
reds='auto')
-def do_axis_reduce(shape, func, arr, dtype, axis, out, identity, cumulative,
+def do_axis_reduce(space, shape, func, arr, dtype, axis, out, identity,
cumulative,
temp):
out_iter = out.create_axis_iter(arr.get_shape(), axis, cumulative)
if cumulative:
@@ -233,7 +233,7 @@
temp_iter = out_iter # hack
arr_iter = arr.create_iter()
if identity is not None:
- identity = identity.convert_to(dtype)
+ identity = identity.convert_to(space, dtype)
shapelen = len(shape)
while not out_iter.done():
axis_reduce__driver.jit_merge_point(shapelen=shapelen, func=func,
@@ -241,7 +241,7 @@
if arr_iter.done():
w_val = identity
else:
- w_val = arr_iter.getitem().convert_to(dtype)
+ w_val = arr_iter.getitem().convert_to(space, dtype)
if out_iter.first_line:
if identity is not None:
w_val = func(dtype, identity, w_val)
@@ -316,11 +316,11 @@
righti = right.create_dot_iter(broadcast_shape, right_skip)
while not outi.done():
dot_driver.jit_merge_point(dtype=dtype)
- lval = lefti.getitem().convert_to(dtype)
- rval = righti.getitem().convert_to(dtype)
- outval = outi.getitem().convert_to(dtype)
+ lval = lefti.getitem().convert_to(space, dtype)
+ rval = righti.getitem().convert_to(space, dtype)
+ outval = outi.getitem().convert_to(space, dtype)
v = dtype.itemtype.mul(lval, rval)
- value = dtype.itemtype.add(v, outval).convert_to(dtype)
+ value = dtype.itemtype.add(v, outval).convert_to(space, dtype)
outi.setitem(value)
outi.next()
righti.next()
@@ -457,7 +457,7 @@
arr_iter.next_skip_x(start)
while length > 0:
flatiter_setitem_driver1.jit_merge_point(dtype=dtype)
- arr_iter.setitem(val_iter.getitem().convert_to(dtype))
+ arr_iter.setitem(val_iter.getitem().convert_to(space, dtype))
# need to repeat i_nput values until all assignments are done
arr_iter.next_skip_x(step)
length -= 1
@@ -610,7 +610,7 @@
index = 0
else:
index = len(iterators) - 1
- out_iter.setitem(iterators[index].getitem().convert_to(dtype))
+ out_iter.setitem(iterators[index].getitem().convert_to(space, dtype))
for iter in iterators:
iter.next()
out_iter.next()
@@ -629,9 +629,9 @@
out_iter = out.create_iter(shape)
while not arr_iter.done():
clip_driver.jit_merge_point(shapelen=shapelen, dtype=dtype)
- w_v = arr_iter.getitem().convert_to(dtype)
- w_min = min_iter.getitem().convert_to(dtype)
- w_max = max_iter.getitem().convert_to(dtype)
+ w_v = arr_iter.getitem().convert_to(space, dtype)
+ w_min = min_iter.getitem().convert_to(space, dtype)
+ w_max = max_iter.getitem().convert_to(space, dtype)
if dtype.itemtype.lt(w_v, w_min):
w_v = w_min
elif dtype.itemtype.gt(w_v, w_max):
@@ -652,7 +652,7 @@
out_iter = out.create_iter(shape)
while not arr_iter.done():
round_driver.jit_merge_point(shapelen=shapelen, dtype=dtype)
- w_v = dtype.itemtype.round(arr_iter.getitem().convert_to(dtype),
+ w_v = dtype.itemtype.round(arr_iter.getitem().convert_to(space, dtype),
decimals)
out_iter.setitem(w_v)
arr_iter.next()
diff --git a/pypy/module/micronumpy/strides.py
b/pypy/module/micronumpy/strides.py
--- a/pypy/module/micronumpy/strides.py
+++ b/pypy/module/micronumpy/strides.py
@@ -62,9 +62,10 @@
if (is_rec_type and space.isinstance_w(w_elem, space.w_tuple)):
return True
if (space.isinstance_w(w_elem, space.w_tuple) or
- isinstance(w_elem, W_NDimArray) or
space.isinstance_w(w_elem, space.w_list)):
return False
+ if isinstance(w_elem, W_NDimArray) and not w_elem.is_scalar():
+ return False
return True
def find_shape_and_elems(space, w_iterable, dtype):
@@ -72,7 +73,6 @@
batch = space.listview(w_iterable)
is_rec_type = dtype is not None and dtype.is_record_type()
while True:
- new_batch = []
if not batch:
return shape[:], []
if is_single_elem(space, batch[0], is_rec_type):
@@ -81,6 +81,7 @@
raise OperationError(space.w_ValueError, space.wrap(
"setting an array element with a sequence"))
return shape[:], batch
+ new_batch = []
size = space.len_w(batch[0])
for w_elem in batch:
if (is_single_elem(space, w_elem, is_rec_type) or
diff --git a/pypy/module/micronumpy/test/dummy_module.py
b/pypy/module/micronumpy/test/dummy_module.py
--- a/pypy/module/micronumpy/test/dummy_module.py
+++ b/pypy/module/micronumpy/test/dummy_module.py
@@ -32,3 +32,8 @@
True_ = bool_(True)
False_ = bool_(False)
+
+def ones(*args, **kwargs):
+ a = zeros(*args, **kwargs)
+ a.fill(1)
+ return a
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
@@ -345,7 +345,7 @@
# TypeError
raises((TypeError, AttributeError), 'x.ndim = 3')
- def test_init(self):
+ def test_zeros(self):
from numpypy import zeros
a = zeros(15)
# Check that storage was actually zero'd.
@@ -355,6 +355,34 @@
assert a[13] == 5.3
assert zeros(()).shape == ()
+ def test_empty_like(self):
+ import numpy as np
+ a = np.empty_like(np.zeros(()))
+ assert a.shape == ()
+ assert a.dtype == np.float_
+ a = np.zeros((2, 3))
+ assert a.shape == (2, 3)
+ a[0,0] = 1
+ b = np.empty_like(a)
+ assert b.shape == a.shape
+ assert b.dtype == a.dtype
+ assert b[0,0] != 1
+ b = np.empty_like(a, dtype='i4')
+ assert b.shape == a.shape
+ assert b.dtype == np.dtype('i4')
+ assert b[0,0] != 1
+ b = np.empty_like([1,2,3])
+ assert b.shape == (3,)
+ assert b.dtype == np.int_
+ class A(np.ndarray):
+ pass
+ b = np.empty_like(A((2, 3)))
+ assert b.shape == (2, 3)
+ assert type(b) is A
+ b = np.empty_like(A((2, 3)), subok=False)
+ assert b.shape == (2, 3)
+ assert type(b) is np.ndarray
+
def test_size(self):
from numpypy import array,arange,cos
assert array(3).size == 1
@@ -455,6 +483,25 @@
a = array(range(5))
assert a[3] == 3
+ def test_list_of_array_init(self):
+ import numpy as np
+ a = np.array([np.array(True), np.array(False)])
+ assert a.shape == (2,)
+ assert a.dtype == np.bool_
+ assert (a == [True, False]).all()
+ a = np.array([np.array(True), np.array(2)])
+ assert a.shape == (2,)
+ assert a.dtype == np.int_
+ assert (a == [1, 2]).all()
+ a = np.array([np.array(True), np.int_(2)])
+ assert a.shape == (2,)
+ assert a.dtype == np.int_
+ assert (a == [1, 2]).all()
+ a = np.array([np.array([True]), np.array([2])])
+ assert a.shape == (2, 1)
+ assert a.dtype == np.int_
+ assert (a == [[1], [2]]).all()
+
def test_getitem(self):
from numpypy import array
a = array(range(5))
@@ -1297,7 +1344,7 @@
assert d[1] == 12
def test_sum(self):
- from numpypy import array, zeros
+ from numpypy import array, zeros, float16, complex64, str_
a = array(range(5))
assert a.sum() == 10
assert a[:4].sum() == 6
@@ -1305,6 +1352,12 @@
a = array([True] * 5, bool)
assert a.sum() == 5
+ assert array([True, False] * 200).sum() == 200
+ assert array([True, False] * 200, dtype='int8').sum() == 200
+ assert array([True, False] * 200).sum(dtype='int8') == -56
+ assert type(array([True, False] * 200, dtype='float16').sum()) is
float16
+ assert type(array([True, False] * 200, dtype='complex64').sum()) is
complex64
+
raises(TypeError, 'a.sum(axis=0, out=3)')
raises(ValueError, 'a.sum(axis=2)')
d = array(0.)
@@ -1347,10 +1400,16 @@
assert (array([[1,2],[3,4]]).prod(1) == [2, 12]).all()
def test_prod(self):
- from numpypy import array
+ from numpypy import array, int_, dtype
a = array(range(1, 6))
assert a.prod() == 120.0
assert a[:4].prod() == 24.0
+ a = array([True, False])
+ assert a.prod() == 0
+ assert type(a.prod()) is int_
+ a = array([True, False], dtype='uint')
+ assert a.prod() == 0
+ assert type(a.prod()) is dtype('uint').type
def test_max(self):
from numpypy import array, zeros
@@ -1973,6 +2032,12 @@
else:
raises(NotImplementedError, array(['1', '2', '3']).astype, float)
+ a = array('123')
+ assert a.astype('i8') == 123
+ a = array('abcdefgh')
+ exc = raises(ValueError, a.astype, 'i8')
+ assert exc.value.message.startswith('invalid literal for int()')
+
def test_base(self):
from numpypy import array
assert array(1).base is None
@@ -2068,6 +2133,11 @@
assert int(array([1])) == 1
assert raises(TypeError, "int(array([1, 2]))")
assert int(array([1.5])) == 1
+ for op in ["int", "float", "long"]:
+ for a in [array('123'), array(['123'])]:
+ exc = raises(TypeError, "%s(a)" % op)
+ assert exc.value.message == "don't know how to convert " \
+ "scalar number to %s" % op
def test__reduce__(self):
from numpypy import array, dtype
@@ -2698,6 +2768,17 @@
assert b[0] == 1
assert b[1] == 'ab'
+ def test_index(self):
+ import numpy as np
+ a = np.array([1], np.uint16)
+ i = a.__index__()
+ assert type(i) is int
+ assert i == 1
+ for a in [np.array('abc'), np.array([1,2]), np.array([True])]:
+ exc = raises(TypeError, a.__index__)
+ assert exc.value.message == 'only integer arrays with one element
' \
+ 'can be converted to an index'
+
def test_int_array_index(self):
from numpypy import array
assert (array([])[[]] == []).all()
diff --git a/pypy/module/micronumpy/test/test_scalar.py
b/pypy/module/micronumpy/test/test_scalar.py
--- a/pypy/module/micronumpy/test/test_scalar.py
+++ b/pypy/module/micronumpy/test/test_scalar.py
@@ -20,6 +20,9 @@
def test_builtin(self):
import numpy as np
+ assert int(np.str_('12')) == 12
+ exc = raises(ValueError, "int(np.str_('abc'))")
+ assert exc.value.message.startswith('invalid literal for int()')
assert oct(np.int32(11)) == '013'
assert oct(np.float32(11.6)) == '013'
assert oct(np.complex64(11-12j)) == '013'
@@ -28,7 +31,10 @@
assert hex(np.complex64(11-12j)) == '0xb'
assert bin(np.int32(11)) == '0b1011'
exc = raises(TypeError, "bin(np.float32(11.6))")
- assert exc.value.message.find('object cannot be interpreted as an
index') != -1
+ assert "index" in exc.value.message
+ exc = raises(TypeError, "len(np.int32(11))")
+ assert "has no len" in exc.value.message
+ assert len(np.string_('123')) == 3
def test_pickle(self):
from numpypy import dtype, zeros
@@ -77,6 +83,9 @@
a = np.bool_(True).astype('int32')
assert type(a) is np.int32
assert a == 1
+ a = np.str_('123').astype('int32')
+ assert type(a) is np.int32
+ assert a == 123
def test_copy(self):
import numpy as np
@@ -86,6 +95,15 @@
assert b == a
assert b is not a
+ def test_buffer(self):
+ import numpy as np
+ a = np.int32(123)
+ b = buffer(a)
+ assert type(b) is buffer
+ a = np.string_('abc')
+ b = buffer(a)
+ assert str(b) == a
+
def test_squeeze(self):
import numpy as np
assert np.True_.squeeze() is np.True_
diff --git a/pypy/module/micronumpy/test/test_subtype.py
b/pypy/module/micronumpy/test/test_subtype.py
--- a/pypy/module/micronumpy/test/test_subtype.py
+++ b/pypy/module/micronumpy/test/test_subtype.py
@@ -33,6 +33,11 @@
self = ndarray.__new__(subtype, shape, dtype)
self.id = 'subtype'
return self
+ a = C((), int)
+ assert type(a) is C
+ assert a.shape == ()
+ assert a.dtype is dtype(int)
+ assert a.id == 'subtype'
a = C([2, 2], int)
assert isinstance(a, C)
assert isinstance(a, ndarray)
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
@@ -1029,22 +1029,6 @@
assert logaddexp2(float('inf'), float('-inf')) == float('inf')
assert logaddexp2(float('inf'), float('inf')) == float('inf')
- def test_ones_like(self):
- from numpypy import array, ones_like
-
- assert ones_like(False) == array(True)
- assert ones_like(2) == array(1)
- assert ones_like(2.) == array(1.)
- assert ones_like(complex(2)) == array(complex(1))
-
- def test_zeros_like(self):
- from numpypy import array, zeros_like
-
- assert zeros_like(True) == array(False)
- assert zeros_like(2) == array(0)
- assert zeros_like(2.) == array(0.)
- assert zeros_like(complex(2)) == array(complex(0))
-
def test_accumulate(self):
from numpypy import add, multiply, arange
assert (add.accumulate([2, 3, 5]) == [2, 5, 10]).all()
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
@@ -300,14 +300,6 @@
def min(self, v1, v2):
return min(v1, v2)
- @simple_unary_op
- def ones_like(self, v):
- return 1
-
- @simple_unary_op
- def zeros_like(self, v):
- return 0
-
@raw_unary_op
def rint(self, v):
float64 = Float64()
@@ -1543,14 +1535,6 @@
except ValueError:
return rfloat.NAN, rfloat.NAN
- @complex_unary_op
- def ones_like(self, v):
- return 1, 0
-
- @complex_unary_op
- def zeros_like(self, v):
- return 0, 0
-
class Complex64(ComplexFloating, BaseType):
T = rffi.FLOAT
BoxType = interp_boxes.W_Complex64Box
diff --git a/pypy/module/test_lib_pypy/test_sha_extra.py
b/pypy/module/test_lib_pypy/test_sha_extra.py
--- a/pypy/module/test_lib_pypy/test_sha_extra.py
+++ b/pypy/module/test_lib_pypy/test_sha_extra.py
@@ -8,7 +8,6 @@
class AppTestSHA:
-
spaceconfig = dict(usemodules=('struct',))
def setup_class(cls):
@@ -37,3 +36,4 @@
assert _sha.blocksize == 1
assert _sha.sha1().digest_size == 20
assert _sha.sha1().digestsize == 20
+ assert _sha.sha1().block_size == 64
diff --git a/pypy/tool/release/package.py b/pypy/tool/release/package.py
--- a/pypy/tool/release/package.py
+++ b/pypy/tool/release/package.py
@@ -115,10 +115,11 @@
continue
print "Picking %s" % p
binaries.append((p, p.basename))
- if pypy_c.dirpath().join("libpypy-c.lib").check():
- shutil.copyfile(str(pypy_c.dirpath().join("libpypy-c.lib")),
+ importlib_name = 'python27.lib'
+ if pypy_c.dirpath().join(importlib_name).check():
+ shutil.copyfile(str(pypy_c.dirpath().join(importlib_name)),
str(pypydir.join('include/python27.lib')))
- print "Picking %s as %s" % (pypy_c.dirpath().join("libpypy-c.lib"),
+ print "Picking %s as %s" % (pypy_c.dirpath().join(importlib_name),
pypydir.join('include/python27.lib'))
else:
pass
_______________________________________________
pypy-commit mailing list
pypy-commit@python.org
https://mail.python.org/mailman/listinfo/pypy-commit
