[pypy-commit] pypy default: store size directly on dtype
bdkearns
noreply at buildbot.pypy.org
Tue Feb 25 03:59:26 CET 2014
Author: Brian Kearns <bdkearns at gmail.com>
Branch:
Changeset: r69382:a49ae1b5d3b4
Date: 2014-02-24 12:03 -0500
http://bitbucket.org/pypy/pypy/changeset/a49ae1b5d3b4/
Log: store size directly on dtype
diff --git a/pypy/module/cpyext/ndarrayobject.py b/pypy/module/cpyext/ndarrayobject.py
--- a/pypy/module/cpyext/ndarrayobject.py
+++ b/pypy/module/cpyext/ndarrayobject.py
@@ -94,12 +94,12 @@
@cpython_api([PyObject], rffi.INT_real, error=CANNOT_FAIL)
def _PyArray_ITEMSIZE(space, w_array):
assert isinstance(w_array, W_NDimArray)
- return w_array.get_dtype().get_size()
+ return w_array.get_dtype().elsize
@cpython_api([PyObject], Py_ssize_t, error=CANNOT_FAIL)
def _PyArray_NBYTES(space, w_array):
assert isinstance(w_array, W_NDimArray)
- return w_array.get_size() * w_array.get_dtype().get_size()
+ return w_array.get_size() * w_array.get_dtype().elsize
@cpython_api([PyObject], rffi.INT_real, error=CANNOT_FAIL)
def _PyArray_TYPE(space, w_array):
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
@@ -55,7 +55,7 @@
loop.setslice(space, shape, self, impl)
def get_size(self):
- return self.size // self.dtype.get_size()
+ return self.size // self.dtype.elsize
def get_storage_size(self):
return self.size
@@ -105,7 +105,7 @@
backstrides = self.get_backstrides()
if self.dtype.is_complex_type():
dtype = self.dtype.get_float_dtype(space)
- return SliceArray(self.start + dtype.get_size(), strides,
+ return SliceArray(self.start + dtype.elsize, strides,
backstrides, self.get_shape(), self, orig_array, dtype=dtype)
impl = NonWritableArray(self.get_shape(), self.dtype, self.order, strides,
backstrides)
@@ -324,7 +324,7 @@
make_sure_not_resized(strides)
make_sure_not_resized(backstrides)
self.shape = shape
- self.size = support.product(shape) * dtype.get_size()
+ self.size = support.product(shape) * dtype.elsize
self.order = order
self.dtype = dtype
self.strides = strides
@@ -352,7 +352,7 @@
self.get_shape())
def fill(self, space, box):
- self.dtype.itemtype.fill(self.storage, self.dtype.get_size(),
+ self.dtype.itemtype.fill(self.storage, self.dtype.elsize,
box, 0, self.size, 0)
def set_shape(self, space, orig_array, new_shape):
@@ -425,7 +425,7 @@
self.storage = parent.storage
self.order = parent.order
self.dtype = dtype
- self.size = support.product(shape) * self.dtype.get_size()
+ self.size = support.product(shape) * self.dtype.elsize
self.start = start
self.orig_arr = orig_arr
@@ -460,12 +460,12 @@
strides = []
backstrides = []
dtype = self.dtype
- s = self.get_strides()[0] // dtype.get_size()
+ s = self.get_strides()[0] // dtype.elsize
if self.order == 'C':
new_shape.reverse()
for sh in new_shape:
- strides.append(s * dtype.get_size())
- backstrides.append(s * (sh - 1) * dtype.get_size())
+ strides.append(s * dtype.elsize)
+ backstrides.append(s * (sh - 1) * dtype.elsize)
s *= max(1, sh)
if self.order == 'C':
strides.reverse()
diff --git a/pypy/module/micronumpy/arrayimpl/sort.py b/pypy/module/micronumpy/arrayimpl/sort.py
--- a/pypy/module/micronumpy/arrayimpl/sort.py
+++ b/pypy/module/micronumpy/arrayimpl/sort.py
@@ -71,10 +71,10 @@
def __init__(self, index_stride_size, stride_size, size):
start = 0
dtype = interp_dtype.get_dtype_cache(space).w_longdtype
- indexes = dtype.itemtype.malloc(size*dtype.get_size())
+ indexes = dtype.itemtype.malloc(size * dtype.elsize)
values = alloc_raw_storage(size * stride_size,
track_allocation=False)
- Repr.__init__(self, dtype.get_size(), stride_size,
+ Repr.__init__(self, dtype.elsize, stride_size,
size, values, indexes, start, start)
def __del__(self):
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
@@ -303,10 +303,10 @@
else:
dtype = space.interp_w(W_Dtype,
space.call_function(space.gettypefor(W_Dtype), w_dtype))
- if dtype.get_size() == 0:
+ if dtype.elsize == 0:
raise OperationError(space.w_TypeError, space.wrap(
"data-type must not be 0-sized"))
- if dtype.get_size() != self.get_dtype(space).get_size():
+ if dtype.elsize != self.get_dtype(space).elsize:
raise OperationError(space.w_ValueError, space.wrap(
"new type not compatible with array."))
if dtype.is_str_or_unicode():
@@ -327,7 +327,7 @@
return space.wrap(1)
def descr_get_itemsize(self, space):
- return self.get_dtype(space).descr_get_itemsize(space)
+ return space.wrap(self.get_dtype(space).elsize)
def descr_get_shape(self, space):
return space.newtuple([])
diff --git a/pypy/module/micronumpy/interp_dtype.py b/pypy/module/micronumpy/interp_dtype.py
--- a/pypy/module/micronumpy/interp_dtype.py
+++ b/pypy/module/micronumpy/interp_dtype.py
@@ -6,7 +6,7 @@
interp_attrproperty, interp_attrproperty_w)
from pypy.module.micronumpy import types, interp_boxes, base
from rpython.rlib.objectmodel import specialize
-from rpython.rlib.rarithmetic import LONG_BIT, r_longlong, r_ulonglong
+from rpython.rlib.rarithmetic import r_longlong, r_ulonglong
from rpython.rlib import jit
from pypy.module.micronumpy.appbridge import get_appbridge_cache
from pypy.module.micronumpy.conversion_utils import byteorder_converter
@@ -39,14 +39,14 @@
class W_Dtype(W_Root):
_immutable_fields_ = [
"num", "kind", "char", "w_box_type", "float_type",
- "itemtype?", "byteorder?", "names?", "fields?", "size?",
+ "itemtype?", "byteorder?", "names?", "fields?", "elsize?",
"shape?", "subdtype?", "base?",
"alternate_constructors", "aliases",
]
def __init__(self, itemtype, num, kind, char, w_box_type,
float_type=None, byteorder=None, names=[], fields={},
- size=1, shape=[], subdtype=None,
+ elsize=None, shape=[], subdtype=None,
alternate_constructors=[], aliases=[]):
self.itemtype = itemtype
self.num = num
@@ -62,7 +62,9 @@
self.byteorder = byteorder
self.names = names
self.fields = fields
- self.size = size
+ if elsize is None:
+ elsize = itemtype.get_element_size()
+ self.elsize = elsize
self.shape = shape
self.subdtype = subdtype
if not subdtype:
@@ -122,9 +124,6 @@
def is_native(self):
return self.byteorder in (NPY.NATIVE, NPY.NATBYTE)
- def get_size(self):
- return self.size * self.itemtype.get_element_size()
-
def get_float_dtype(self, space):
assert self.kind == NPY.COMPLEXLTR
assert self.float_type is not None
@@ -158,14 +157,14 @@
byteorder = NPY.NATBYTE if self.is_native() else NPY.OPPBYTE
else:
byteorder = ''
- r = space.wrap(byteorder + self.char + str(self.size))
+ size = self.elsize
+ if self.num == NPY.UNICODE:
+ size >>= 2
+ r = space.wrap(byteorder + self.char + str(size))
else:
r = self.descr_get_name(space)
return space.wrap("dtype(%s)" % space.str_w(space.repr(r)))
- def descr_get_itemsize(self, space):
- return space.wrap(self.get_size())
-
def descr_get_alignment(self, space):
return space.wrap(self.itemtype.alignment)
@@ -187,22 +186,18 @@
name = self.get_name()
if name[-1] == '_':
name = name[:-1]
- if self.is_flexible_type():
- return space.wrap(name + str(self.get_size() * 8))
+ if self.is_flexible_type() and self.elsize != 0:
+ return space.wrap(name + str(self.elsize * 8))
return space.wrap(name)
def descr_get_str(self, space):
- size = self.get_size()
basic = self.kind
- if basic == NPY.UNICODELTR:
+ endian = self.byteorder
+ size = self.elsize
+ if endian == NPY.NATIVE:
+ endian = NPY.NATBYTE
+ if self.num == NPY.UNICODE:
size >>= 2
- endian = NPY.NATBYTE
- elif size // (self.size or 1) <= 1:
- endian = NPY.IGNORE
- else:
- endian = self.byteorder
- if endian == NPY.NATIVE:
- endian = NPY.NATBYTE
return space.wrap("%s%s%s" % (endian, basic, size))
def descr_get_descr(self, space):
@@ -240,7 +235,8 @@
if space.is_w(self, w_other):
return True
if isinstance(w_other, W_Dtype):
- return space.eq_w(self.descr_reduce(space), w_other.descr_reduce(space))
+ return space.eq_w(self.descr_reduce(space),
+ w_other.descr_reduce(space))
return False
def descr_eq(self, space, w_other):
@@ -326,10 +322,9 @@
def descr_reduce(self, space):
w_class = space.type(self)
-
- size = self.get_size()
- builder_args = space.newtuple([space.wrap("%s%d" % (self.kind, size)),
- space.wrap(0), space.wrap(1)])
+ builder_args = space.newtuple([
+ space.wrap("%s%d" % (self.kind, self.elsize)),
+ space.wrap(0), space.wrap(1)])
version = space.wrap(3)
endian = self.byteorder
@@ -339,7 +334,7 @@
names = self.descr_get_names(space)
values = self.descr_get_fields(space)
if self.is_flexible_type():
- w_size = space.wrap(size)
+ w_size = space.wrap(self.elsize)
alignment = space.wrap(self.itemtype.alignment)
else:
w_size = space.wrap(-1)
@@ -407,7 +402,7 @@
self.itemtype = types.RecordType()
if self.is_flexible_type():
- self.size = size
+ self.elsize = size
@unwrap_spec(new_order=str)
def descr_newbyteorder(self, space, new_order=NPY.SWAP):
@@ -421,7 +416,7 @@
itemtype = self.itemtype.__class__(endian in (NPY.NATIVE, NPY.NATBYTE))
return W_Dtype(itemtype, self.num, self.kind, self.char,
self.w_box_type, self.float_type, byteorder=endian,
- size=self.size)
+ elsize=self.elsize)
@specialize.arg(2)
@@ -451,11 +446,11 @@
raise oefmt(space.w_ValueError, "two fields with the same name")
assert isinstance(subdtype, W_Dtype)
fields[fldname] = (offset, subdtype)
- offset += subdtype.get_size()
+ offset += subdtype.elsize
names.append(fldname)
return W_Dtype(types.RecordType(), NPY.VOID, NPY.VOIDLTR, NPY.VOIDLTR,
space.gettypefor(interp_boxes.W_VoidBox),
- names=names, fields=fields, size=offset)
+ names=names, fields=fields, elsize=offset)
def dtype_from_dict(space, w_dict):
@@ -494,10 +489,10 @@
size *= dim
if size == 1:
return subdtype
- size *= subdtype.get_size()
+ size *= subdtype.elsize
return W_Dtype(types.VoidType(), NPY.VOID, NPY.VOIDLTR, NPY.VOIDLTR,
space.gettypefor(interp_boxes.W_VoidBox),
- shape=shape, subdtype=subdtype, size=size)
+ shape=shape, subdtype=subdtype, elsize=size)
if space.is_none(w_dtype):
return cache.w_float64dtype
@@ -526,7 +521,7 @@
w_dtype1 = space.getitem(w_dtype, space.wrap(1))
subdtype = descr__new__(space, w_subtype, w_dtype0, w_align, w_copy)
assert isinstance(subdtype, W_Dtype)
- if subdtype.get_size() == 0:
+ if subdtype.elsize == 0:
name = "%s%d" % (subdtype.kind, space.int_w(w_dtype1))
return descr__new__(space, w_subtype, space.wrap(name), w_align, w_copy)
return descr__new__(space, w_subtype, w_dtype0, w_align, w_copy, w_shape=w_dtype1)
@@ -562,22 +557,22 @@
char = interp_attrproperty("char", cls=W_Dtype),
num = interp_attrproperty("num", cls=W_Dtype),
byteorder = interp_attrproperty("byteorder", cls=W_Dtype),
- itemsize = GetSetProperty(W_Dtype.descr_get_itemsize),
+ itemsize = interp_attrproperty("elsize", cls=W_Dtype),
alignment = GetSetProperty(W_Dtype.descr_get_alignment),
- isbuiltin = GetSetProperty(W_Dtype.descr_get_isbuiltin),
subdtype = GetSetProperty(W_Dtype.descr_get_subdtype),
+ descr = GetSetProperty(W_Dtype.descr_get_descr),
str = GetSetProperty(W_Dtype.descr_get_str),
name = GetSetProperty(W_Dtype.descr_get_name),
base = GetSetProperty(W_Dtype.descr_get_base),
shape = GetSetProperty(W_Dtype.descr_get_shape),
+ isbuiltin = GetSetProperty(W_Dtype.descr_get_isbuiltin),
isnative = GetSetProperty(W_Dtype.descr_get_isnative),
fields = GetSetProperty(W_Dtype.descr_get_fields),
names = GetSetProperty(W_Dtype.descr_get_names,
W_Dtype.descr_set_names,
W_Dtype.descr_del_names),
hasobject = GetSetProperty(W_Dtype.descr_get_hasobject),
- descr = GetSetProperty(W_Dtype.descr_get_descr),
)
W_Dtype.typedef.acceptable_as_base_class = False
@@ -609,7 +604,7 @@
def new_string_dtype(space, size):
return W_Dtype(
types.StringType(),
- size=size,
+ elsize=size,
num=NPY.STRING,
kind=NPY.STRINGLTR,
char=NPY.STRINGLTR,
@@ -618,9 +613,10 @@
def new_unicode_dtype(space, size):
+ itemtype = types.UnicodeType()
return W_Dtype(
- types.UnicodeType(),
- size=size,
+ itemtype,
+ elsize=size * itemtype.get_element_size(),
num=NPY.UNICODE,
kind=NPY.UNICODELTR,
char=NPY.UNICODELTR,
@@ -631,7 +627,7 @@
def new_void_dtype(space, size):
return W_Dtype(
types.VoidType(),
- size=size,
+ elsize=size,
num=NPY.VOID,
kind=NPY.VOIDLTR,
char=NPY.VOIDLTR,
@@ -794,7 +790,7 @@
)
self.w_stringdtype = W_Dtype(
types.StringType(),
- size=0,
+ elsize=0,
num=NPY.STRING,
kind=NPY.STRINGLTR,
char=NPY.STRINGLTR,
@@ -805,7 +801,7 @@
)
self.w_unicodedtype = W_Dtype(
types.UnicodeType(),
- size=0,
+ elsize=0,
num=NPY.UNICODE,
kind=NPY.UNICODELTR,
char=NPY.UNICODELTR,
@@ -815,7 +811,7 @@
)
self.w_voiddtype = W_Dtype(
types.VoidType(),
- size=0,
+ elsize=0,
num=NPY.VOID,
kind=NPY.VOIDLTR,
char=NPY.VOIDLTR,
@@ -862,7 +858,7 @@
self.w_intpdtype, self.w_uintpdtype,
]
self.float_dtypes_by_num_bytes = sorted(
- (dtype.get_size(), dtype)
+ (dtype.elsize, dtype)
for dtype in float_dtypes
)
self.dtypes_by_num = {}
@@ -873,7 +869,7 @@
dtype.fields = None # mark these as builtin
self.dtypes_by_num[dtype.num] = dtype
self.dtypes_by_name[dtype.get_name()] = dtype
- for can_name in [dtype.kind + str(dtype.get_size()),
+ for can_name in [dtype.kind + str(dtype.elsize),
dtype.char]:
self.dtypes_by_name[can_name] = dtype
self.dtypes_by_name[NPY.NATBYTE + can_name] = dtype
@@ -928,7 +924,7 @@
for k, v in typeinfo_partial.iteritems():
space.setitem(w_typeinfo, space.wrap(k), space.gettypefor(v))
for k, dtype in typeinfo_full.iteritems():
- itembits = dtype.get_size() * 8
+ itembits = dtype.elsize * 8
items_w = [space.wrap(dtype.char),
space.wrap(dtype.num),
space.wrap(itembits),
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
@@ -87,7 +87,7 @@
def descr_set_dtype(self, space, w_dtype):
dtype = space.interp_w(interp_dtype.W_Dtype,
space.call_function(space.gettypefor(interp_dtype.W_Dtype), w_dtype))
- if (dtype.get_size() != self.get_dtype().get_size() or
+ if (dtype.elsize != self.get_dtype().elsize or
dtype.is_flexible_type() or self.get_dtype().is_flexible_type()):
raise OperationError(space.w_ValueError, space.wrap(
"new type not compatible with array."))
@@ -101,10 +101,10 @@
return space.wrap(len(self.get_shape()))
def descr_get_itemsize(self, space):
- return space.wrap(self.get_dtype().get_size())
+ return space.wrap(self.get_dtype().elsize)
def descr_get_nbytes(self, space):
- return space.wrap(self.get_size() * self.get_dtype().get_size())
+ return space.wrap(self.get_size() * self.get_dtype().elsize)
def descr_fill(self, space, w_value):
self.fill(space, self.get_dtype().coerce(space, w_value))
@@ -575,10 +575,10 @@
raise oefmt(space.w_NotImplementedError,
"astype(%s) not implemented yet",
new_dtype.get_name())
- if new_dtype.num == NPY.STRING and new_dtype.size == 0:
+ if new_dtype.num == NPY.STRING and new_dtype.elsize == 0:
if cur_dtype.num == NPY.STRING:
new_dtype = interp_dtype.variable_dtype(space,
- 'S' + str(cur_dtype.size))
+ 'S' + str(cur_dtype.elsize))
impl = self.implementation
if isinstance(impl, scalar.Scalar):
return W_NDimArray.new_scalar(space, new_dtype, impl.value)
@@ -781,8 +781,8 @@
w_dtype))
else:
dtype = self.get_dtype()
- old_itemsize = self.get_dtype().get_size()
- new_itemsize = dtype.get_size()
+ old_itemsize = self.get_dtype().elsize
+ new_itemsize = dtype.elsize
impl = self.implementation
if new_itemsize == 0:
raise OperationError(space.w_TypeError, space.wrap(
@@ -1188,7 +1188,7 @@
if not shape:
raise OperationError(space.w_TypeError, space.wrap(
"numpy scalars from buffers not supported yet"))
- totalsize = support.product(shape) * dtype.get_size()
+ totalsize = support.product(shape) * dtype.elsize
if totalsize+offset > buf.getlength():
raise OperationError(space.w_TypeError, space.wrap(
"buffer is too small for requested array"))
@@ -1448,7 +1448,7 @@
# scalars and strings w/o __array__ method
isstr = space.isinstance_w(w_object, space.w_str)
if not issequence_w(space, w_object) or isstr:
- 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.elsize < 1):
dtype = interp_ufuncs.find_dtype_for_scalar(space, w_object)
return W_NDimArray.new_scalar(space, dtype, w_object)
@@ -1478,14 +1478,14 @@
# 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.elsize < 1):
for w_elem in elems_w:
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
- elif dtype.is_str_or_unicode() and dtype.get_size() < 1:
+ elif dtype.is_str_or_unicode() and dtype.elsize < 1:
# promote S0 -> S1, U0 -> U1
dtype = interp_dtype.variable_dtype(space, dtype.char + '1')
@@ -1501,7 +1501,7 @@
def zeros(space, w_shape, w_dtype=None, w_order=None):
dtype = space.interp_w(interp_dtype.W_Dtype,
space.call_function(space.gettypefor(interp_dtype.W_Dtype), w_dtype))
- if dtype.is_str_or_unicode() and dtype.get_size() < 1:
+ if dtype.is_str_or_unicode() and dtype.elsize < 1:
dtype = interp_dtype.variable_dtype(space, dtype.char + '1')
shape = _find_shape(space, w_shape, dtype)
return W_NDimArray.from_shape(space, shape, dtype=dtype)
@@ -1514,7 +1514,7 @@
else:
dtype = space.interp_w(interp_dtype.W_Dtype,
space.call_function(space.gettypefor(interp_dtype.W_Dtype), w_dtype))
- if dtype.is_str_or_unicode() and dtype.get_size() < 1:
+ if dtype.is_str_or_unicode() and dtype.elsize < 1:
dtype = interp_dtype.variable_dtype(space, dtype.char + '1')
return W_NDimArray.from_shape(space, w_a.get_shape(), dtype=dtype,
w_instance=w_a if subok else None)
diff --git a/pypy/module/micronumpy/interp_support.py b/pypy/module/micronumpy/interp_support.py
--- a/pypy/module/micronumpy/interp_support.py
+++ b/pypy/module/micronumpy/interp_support.py
@@ -59,7 +59,7 @@
return space.wrap(a)
def _fromstring_bin(space, s, count, length, dtype):
- itemsize = dtype.get_size()
+ itemsize = dtype.elsize
assert itemsize >= 0
if count == -1:
count = length / itemsize
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
@@ -519,7 +519,7 @@
if dt2.is_record_type():
return dt2
if dt1.is_str_or_unicode():
- if dt2.get_size() >= dt1.get_size():
+ if dt2.elsize >= dt1.elsize:
return dt2
return dt1
return dt2
@@ -542,10 +542,10 @@
promote_bools=False, promote_to_largest=False):
if promote_to_largest:
if dt.kind == NPY.GENBOOLLTR or dt.kind == NPY.SIGNEDLTR:
- if dt.get_size() * 8 < LONG_BIT:
+ if dt.elsize * 8 < LONG_BIT:
return interp_dtype.get_dtype_cache(space).w_longdtype
elif dt.kind == NPY.UNSIGNEDLTR:
- if dt.get_size() * 8 < LONG_BIT:
+ if dt.elsize * 8 < LONG_BIT:
return interp_dtype.get_dtype_cache(space).w_ulongdtype
else:
assert dt.kind == NPY.FLOATINGLTR or dt.kind == NPY.COMPLEXLTR
@@ -596,7 +596,7 @@
return interp_dtype.variable_dtype(space,
'S%d' % space.len_w(w_obj))
elif current_guess.num == NPY.STRING:
- if current_guess.get_size() < space.len_w(w_obj):
+ if current_guess.elsize < space.len_w(w_obj):
return interp_dtype.variable_dtype(space,
'S%d' % space.len_w(w_obj))
return current_guess
diff --git a/pypy/module/micronumpy/iter.py b/pypy/module/micronumpy/iter.py
--- a/pypy/module/micronumpy/iter.py
+++ b/pypy/module/micronumpy/iter.py
@@ -174,7 +174,7 @@
def __init__(self, array):
self.array = array
self.offset = 0
- self.skip = array.dtype.get_size()
+ self.skip = array.dtype.elsize
self.size = array.size
def setitem(self, elem):
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
@@ -459,7 +459,7 @@
builder = StringBuilder()
iter = arr.create_iter()
w_res_str = W_NDimArray.from_shape(space, [1], arr.get_dtype(), order='C')
- itemsize = arr.get_dtype().get_size()
+ itemsize = arr.get_dtype().elsize
res_str_casted = rffi.cast(rffi.CArrayPtr(lltype.Char),
w_res_str.implementation.get_storage_as_int(space))
while not iter.done():
diff --git a/pypy/module/micronumpy/support.py b/pypy/module/micronumpy/support.py
--- a/pypy/module/micronumpy/support.py
+++ b/pypy/module/micronumpy/support.py
@@ -28,8 +28,8 @@
shape_rev.reverse()
for sh in shape_rev:
slimit = max(sh, 1)
- strides.append(s * dtype.get_size())
- backstrides.append(s * (slimit - 1) * dtype.get_size())
+ strides.append(s * dtype.elsize)
+ backstrides.append(s * (slimit - 1) * dtype.elsize)
s *= slimit
if order == 'C':
strides.reverse()
diff --git a/pypy/module/micronumpy/test/test_dtypes.py b/pypy/module/micronumpy/test/test_dtypes.py
--- a/pypy/module/micronumpy/test/test_dtypes.py
+++ b/pypy/module/micronumpy/test/test_dtypes.py
@@ -58,6 +58,7 @@
assert dtype('int8').num == 1
assert dtype('int8').name == 'int8'
+ assert dtype('void').name == 'void'
assert dtype(int).fields is None
assert dtype(int).names is None
assert dtype(int).hasobject is False
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
@@ -14,15 +14,9 @@
def malloc(size):
return None
- @staticmethod
- def get_element_size():
- return 1
-
def __init__(self):
self.base = self
-
- def get_size(self):
- return 1
+ self.elsize = 1
def create_slice(space, a, chunks):
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
@@ -1628,7 +1628,7 @@
builder = StringBuilder()
assert isinstance(item, interp_boxes.W_FlexibleBox)
i = item.ofs
- end = i + item.dtype.get_size()
+ end = i + item.dtype.elsize
while i < end:
assert isinstance(item.arr.storage[i], str)
if item.arr.storage[i] == '\x00':
@@ -1664,17 +1664,17 @@
if w_item is None:
w_item = space.wrap('')
arg = space.str_w(space.str(w_item))
- arr = VoidBoxStorage(dtype.size, dtype)
- j = min(len(arg), dtype.size)
+ arr = VoidBoxStorage(dtype.elsize, dtype)
+ j = min(len(arg), dtype.elsize)
for i in range(j):
arr.storage[i] = arg[i]
- for j in range(j, dtype.size):
+ for j in range(j, dtype.elsize):
arr.storage[j] = '\x00'
return interp_boxes.W_StringBox(arr, 0, arr.dtype)
def store(self, arr, i, offset, box):
assert isinstance(box, interp_boxes.W_StringBox)
- size = min(arr.dtype.size - offset, box.arr.size - box.ofs)
+ size = min(arr.dtype.elsize - offset, box.arr.size - box.ofs)
return self._store(arr.storage, i, offset, box, size)
@jit.unroll_safe
@@ -1784,7 +1784,7 @@
ofs += size
def coerce(self, space, dtype, w_items):
- arr = VoidBoxStorage(dtype.get_size(), dtype)
+ arr = VoidBoxStorage(dtype.elsize, dtype)
self._coerce(space, arr, 0, dtype, w_items, dtype.shape)
return interp_boxes.W_VoidBox(arr, 0, dtype)
@@ -1793,7 +1793,7 @@
assert i == 0
assert isinstance(box, interp_boxes.W_VoidBox)
assert box.dtype is box.arr.dtype
- for k in range(box.arr.dtype.get_size()):
+ for k in range(box.arr.dtype.elsize):
arr.storage[k + ofs] = box.arr.storage[k + box.ofs]
def readarray(self, arr, i, offset, dtype=None):
@@ -1867,7 +1867,7 @@
items_w = [w_item]
else:
items_w = [None] * len(dtype.fields)
- arr = VoidBoxStorage(dtype.get_size(), dtype)
+ arr = VoidBoxStorage(dtype.elsize, dtype)
for i in range(len(dtype.fields)):
ofs, subdtype = dtype.fields[dtype.names[i]]
itemtype = subdtype.itemtype
@@ -1884,7 +1884,7 @@
def store(self, arr, i, ofs, box):
assert isinstance(box, interp_boxes.W_VoidBox)
- self._store(arr.storage, i, ofs, box, box.dtype.get_size())
+ self._store(arr.storage, i, ofs, box, box.dtype.elsize)
@jit.unroll_safe
def _store(self, storage, i, ofs, box, size):
@@ -1893,7 +1893,7 @@
def fill(self, storage, width, box, start, stop, offset):
assert isinstance(box, interp_boxes.W_VoidBox)
- assert width == box.dtype.get_size()
+ assert width == box.dtype.elsize
for i in xrange(start, stop, width):
self._store(storage, i, offset, box, width)
@@ -1932,8 +1932,8 @@
def eq(self, v1, v2):
assert isinstance(v1, interp_boxes.W_VoidBox)
assert isinstance(v2, interp_boxes.W_VoidBox)
- s1 = v1.dtype.get_size()
- s2 = v2.dtype.get_size()
+ s1 = v1.dtype.elsize
+ s2 = v2.dtype.elsize
assert s1 == s2
for i in range(s1):
if v1.arr.storage[v1.ofs + i] != v2.arr.storage[v2.ofs + i]:
More information about the pypy-commit
mailing list